Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
3032 mandeep.dh 49 
  def getUserByMobileNumber(self, mobileNumber):
50 
    """
51 
    Parameters:
52 
     - mobileNumber
53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def createUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def updateUser(self, user):
94 ashish 64 
    """
65 
    Parameters:
559 chandransh 66 
     - user
94 ashish 67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def deleteUser(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def getUserState(self, userId):
94 ashish 78 
    """
79 
    Parameters:
80 
     - userId
81 
    """
82 
    pass
83 
 
559 chandransh 84 
  def authenticateUser(self, email, password):
94 ashish 85 
    """
86 
    Parameters:
87 
     - email
88 
     - password
89 
    """
90 
    pass
91 
 
92 
  def userExists(self, email):
93 
    """
94 
    Parameters:
95 
     - email
96 
    """
97 
    pass
98 
 
567 rajveer 99 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 100 
    """
101 
    Parameters:
102 
     - userId
103 
     - address
513 rajveer 104 
     - setDefault
94 ashish 105 
    """
106 
    pass
107 
 
108 
  def removeAddressForUser(self, userid, addressId):
109 
    """
110 
    Parameters:
111 
     - userid
112 
     - addressId
113 
    """
114 
    pass
115 
 
116 
  def setUserAsLoggedIn(self, userId, timestamp):
117 
    """
118 
    Parameters:
119 
     - userId
120 
     - timestamp
121 
    """
122 
    pass
123 
 
124 
  def setUserAsLoggedOut(self, userid, timestamp):
125 
    """
126 
    Parameters:
127 
     - userid
128 
     - timestamp
129 
    """
130 
    pass
131 
 
504 rajveer 132 
  def setDefaultAddress(self, userid, addressId):
133 
    """
134 
    Parameters:
135 
     - userid
136 
     - addressId
137 
    """
138 
    pass
139 
 
594 rajveer 140 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 141 
    """
142 
    Parameters:
143 
     - userid
594 rajveer 144 
     - oldPassword
145 
     - newPassword
94 ashish 146 
    """
147 
    pass
148 
 
884 rajveer 149 
  def forgotPassword(self, email, newPassword):
581 rajveer 150 
    """
151 
    Parameters:
152 
     - email
884 rajveer 153 
     - newPassword
581 rajveer 154 
    """
155 
    pass
156 
 
594 rajveer 157 
  def getAllAddressesForUser(self, userId):
158 
    """
159 
    Parameters:
160 
     - userId
161 
    """
162 
    pass
163 
 
1894 vikas 164 
  def getAddressById(self, addressId):
165 
    """
166 
    Parameters:
167 
     - addressId
168 
    """
169 
    pass
170 
 
594 rajveer 171 
  def getDefaultAddressId(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
785 rajveer 178 
  def getDefaultPincode(self, userId):
179 
    """
180 
    Parameters:
181 
     - userId
182 
    """
183 
    pass
184 
 
1274 varun.gupt 185 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
186 
    """
187 
    Parameters:
188 
     - userId
189 
     - replyTo
190 
     - communicationType
191 
     - orderId
192 
     - airwaybillNo
193 
     - productName
194 
     - subject
195 
     - message
196 
    """
197 
    pass
198 
 
1590 varun.gupt 199 
  def getUserCommunicationById(self, id):
200 
    """
201 
    Parameters:
202 
     - id
203 
    """
204 
    pass
205 
 
206 
  def getUserCommunicationByUser(self, userId):
207 
    """
208 
    Parameters:
209 
     - userId
210 
    """
211 
    pass
212 
 
213 
  def getAllUserCommunications(self, ):
214 
    pass
215 
 
1859 vikas 216 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 217 
    """
218 
    Parameters:
219 
     - name
1859 vikas 220 
     - addedOn
1845 vikas 221 
    """
222 
    pass
223 
 
1899 vikas 224 
  def getAllMasterAffiliates(self, ):
225 
    pass
226 
 
1845 vikas 227 
  def getMasterAffiliateById(self, id):
228 
    """
229 
    Parameters:
230 
     - id
231 
    """
232 
    pass
233 
 
234 
  def getMasterAffiliateByName(self, name):
235 
    """
236 
    Parameters:
237 
     - name
238 
    """
239 
    pass
240 
 
1859 vikas 241 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 242 
    """
243 
    Parameters:
244 
     - name
245 
     - url
246 
     - masterAffiliateId
1859 vikas 247 
     - addedOn
1845 vikas 248 
    """
249 
    pass
250 
 
251 
  def getAffiliateById(self, id):
252 
    """
253 
    Parameters:
254 
     - id
255 
    """
256 
    pass
257 
 
258 
  def getAffiliateByName(self, name):
259 
    """
260 
    Parameters:
261 
     - name
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getTrackerById(self, id):
1845 vikas 266 
    """
267 
    Parameters:
268 
     - id
269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 273 
    """
274 
    Parameters:
1996 vikas 275 
     - id
1845 vikas 276 
    """
277 
    pass
278 
 
1996 vikas 279 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 280 
    """
281 
    Parameters:
282 
     - affiliateId
283 
     - userId
284 
     - event
285 
     - url
286 
     - data
1859 vikas 287 
     - addedOn
1845 vikas 288 
    """
289 
    pass
290 
 
291 
  def getTrackLogById(self, id):
292 
    """
293 
    Parameters:
294 
     - id
295 
    """
296 
    pass
297 
 
1996 vikas 298 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 299 
    """
300 
    Parameters:
1996 vikas 301 
     - affiliateId
1845 vikas 302 
    """
303 
    pass
304 
 
305 
  def getTrackLogsByUser(self, userId):
306 
    """
307 
    Parameters:
308 
     - userId
309 
    """
310 
    pass
311 
 
1996 vikas 312 
  def getTrackLogs(self, userId, event, url):
1845 vikas 313 
    """
314 
    Parameters:
315 
     - userId
316 
     - event
317 
     - url
318 
    """
319 
    pass
320 
 
559 chandransh 321 
  def createCart(self, userId):
94 ashish 322 
    """
323 
    Parameters:
559 chandransh 324 
     - userId
94 ashish 325 
    """
326 
    pass
327 
 
559 chandransh 328 
  def getCurrentCart(self, userId):
94 ashish 329 
    """
330 
    Parameters:
559 chandransh 331 
     - userId
94 ashish 332 
    """
333 
    pass
334 
 
559 chandransh 335 
  def getCart(self, cartId):
94 ashish 336 
    """
337 
    Parameters:
559 chandransh 338 
     - cartId
94 ashish 339 
    """
340 
    pass
341 
 
559 chandransh 342 
  def getCartsForUser(self, userId, status):
94 ashish 343 
    """
344 
    Parameters:
559 chandransh 345 
     - userId
346 
     - status
94 ashish 347 
    """
348 
    pass
349 
 
559 chandransh 350 
  def getCartsByStatus(self, status):
94 ashish 351 
    """
352 
    Parameters:
559 chandransh 353 
     - status
94 ashish 354 
    """
355 
    pass
356 
 
559 chandransh 357 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 358 
    """
359 
    Parameters:
559 chandransh 360 
     - from_time
361 
     - to_time
362 
     - status
94 ashish 363 
    """
364 
    pass
365 
 
559 chandransh 366 
  def changeCartStatus(self, cartId, status):
130 ashish 367 
    """
368 
    Parameters:
559 chandransh 369 
     - cartId
370 
     - status
130 ashish 371 
    """
372 
    pass
94 ashish 373 
 
559 chandransh 374 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 375 
    """
376 
    Parameters:
559 chandransh 377 
     - cartId
378 
     - itemId
379 
     - quantity
130 ashish 380 
    """
381 
    pass
382 
 
559 chandransh 383 
  def deleteItemFromCart(self, cartId, itemId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
     - itemId
388 
    """
389 
    pass
130 ashish 390 
 
559 chandransh 391 
  def changeQuantity(self, cartId, itemId, quantity):
392 
    """
393 
    Parameters:
394 
     - cartId
395 
     - itemId
396 
     - quantity
397 
    """
398 
    pass
399 
 
400 
  def changeItemStatus(self, cartId, itemId, status):
401 
    """
402 
    Parameters:
403 
     - cartId
404 
     - itemId
405 
     - status
406 
    """
407 
    pass
408 
 
409 
  def addAddressToCart(self, cartId, addressId):
410 
    """
411 
    Parameters:
412 
     - cartId
413 
     - addressId
414 
    """
415 
    pass
416 
 
1976 varun.gupt 417 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
418 
    """
419 
    Parameters:
420 
     - cartId
421 
     - couponCode
422 
     - totalPrice
423 
     - discountedPrice
424 
    """
425 
    pass
426 
 
427 
  def removeCoupon(self, cartId):
428 
    """
429 
    Parameters:
430 
     - cartId
431 
    """
432 
    pass
433 
 
2815 vikas 434 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 435 
    """
690 chandransh 436 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
437 
 
559 chandransh 438 
    Parameters:
439 
     - cartId
2815 vikas 440 
     - sessionSource
441 
     - sessionStartTime
559 chandransh 442 
    """
443 
    pass
444 
 
445 
  def validateCart(self, cartId):
446 
    """
690 chandransh 447 
    Validates that:
448 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 449 
    2. All of the lines in the cart are active items.
690 chandransh 450 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 451 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 452 
 
559 chandransh 453 
    Parameters:
454 
     - cartId
455 
    """
456 
    pass
457 
 
690 chandransh 458 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 459 
    """
690 chandransh 460 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
461 
 
575 chandransh 462 
    Parameters:
690 chandransh 463 
     - fromCartId
464 
     - toCartId
465 
    """
466 
    pass
467 
 
468 
  def checkOut(self, cartId):
469 
    """
470 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
471 
 
472 
    Parameters:
575 chandransh 473 
     - cartId
474 
    """
475 
    pass
476 
 
690 chandransh 477 
  def resetCart(self, cartId, items):
559 chandransh 478 
    """
690 chandransh 479 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
480 
    This methods removes the specified quantiry of the specified item from the cart.
481 
 
559 chandransh 482 
    Parameters:
690 chandransh 483 
     - cartId
484 
     - items
559 chandransh 485 
    """
486 
    pass
487 
 
2981 rajveer 488 
  def getUserCount(self, userType):
559 chandransh 489 
    """
2981 rajveer 490 
    Returns number of registered users.
491 
    If userType = null, then it returns count of all users, including anonymous
492 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
493 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 494 
 
559 chandransh 495 
    Parameters:
2981 rajveer 496 
     - userType
559 chandransh 497 
    """
498 
    pass
499 
 
2981 rajveer 500 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 501 
    """
2981 rajveer 502 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
503 
    If any of startDate or endDate is -1, then that filter is ignored.
504 
    If userType is null, then returns all the users, irrespective of anonymous flag
505 
 
506 
 
559 chandransh 507 
    Parameters:
2981 rajveer 508 
     - userType
509 
     - startDate
510 
     - endDate
559 chandransh 511 
    """
512 
    pass
513 
 
2981 rajveer 514 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 515 
    """
516 
    Parameters:
2981 rajveer 517 
     - user_id
518 
     - entity_id
519 
     - slide
520 
     - note
559 chandransh 521 
    """
522 
    pass
523 
 
2981 rajveer 524 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 525 
    """
526 
    Parameters:
2981 rajveer 527 
     - user_id
528 
     - entity_id
559 chandransh 529 
    """
530 
    pass
531 
 
2981 rajveer 532 
  def getMyResearchItems(self, userId):
559 chandransh 533 
    """
2981 rajveer 534 
    Returns list of item ids in myresearch for the user
535 
 
559 chandransh 536 
    Parameters:
537 
     - userId
538 
    """
539 
    pass
540 
 
2981 rajveer 541 
  def updateMyResearch(self, userId, itemId):
559 chandransh 542 
    """
2981 rajveer 543 
    add item to my research for a user
544 
 
559 chandransh 545 
    Parameters:
2981 rajveer 546 
     - userId
547 
     - itemId
559 chandransh 548 
    """
549 
    pass
550 
 
2981 rajveer 551 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 552 
    """
2981 rajveer 553 
    delete item from my research for a user
1596 ankur.sing 554 
 
555 
    Parameters:
2981 rajveer 556 
     - userId
557 
     - itemId
1596 ankur.sing 558 
    """
559 
    pass
559 chandransh 560 
 
2981 rajveer 561 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 562 
    """
2981 rajveer 563 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 564 
 
565 
    Parameters:
2981 rajveer 566 
     - userId
1673 ankur.sing 567 
    """
568 
    pass
1596 ankur.sing 569 
 
2981 rajveer 570 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 571 
    """
2981 rajveer 572 
    add item to browse history for a user
2642 varun.gupt 573 
 
574 
    Parameters:
2981 rajveer 575 
     - userId
576 
     - itemId
2642 varun.gupt 577 
    """
578 
    pass
1673 ankur.sing 579 
 
2642 varun.gupt 580 
 
94 ashish 581 
class Client(Iface):
582 
  """
583 
  service
584 
  """
585 
  def __init__(self, iprot, oprot=None):
586 
    self._iprot = self._oprot = iprot
587 
    if oprot != None:
588 
      self._oprot = oprot
589 
    self._seqid = 0
590 
 
765 rajveer 591 
  def closeSession(self, ):
592 
    """
593 
    For closing the open session in sqlalchemy
594 
    """
595 
    self.send_closeSession()
596 
    self.recv_closeSession()
597 
 
598 
  def send_closeSession(self, ):
599 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
600 
    args = closeSession_args()
601 
    args.write(self._oprot)
602 
    self._oprot.writeMessageEnd()
603 
    self._oprot.trans.flush()
604 
 
605 
  def recv_closeSession(self, ):
606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
607 
    if mtype == TMessageType.EXCEPTION:
608 
      x = TApplicationException()
609 
      x.read(self._iprot)
610 
      self._iprot.readMessageEnd()
611 
      raise x
612 
    result = closeSession_result()
613 
    result.read(self._iprot)
614 
    self._iprot.readMessageEnd()
615 
    return
616 
 
559 chandransh 617 
  def createAnonymousUser(self, jsessionId):
94 ashish 618 
    """
619 
    Parameters:
559 chandransh 620 
     - jsessionId
94 ashish 621 
    """
559 chandransh 622 
    self.send_createAnonymousUser(jsessionId)
623 
    return self.recv_createAnonymousUser()
94 ashish 624 
 
559 chandransh 625 
  def send_createAnonymousUser(self, jsessionId):
626 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
627 
    args = createAnonymousUser_args()
628 
    args.jsessionId = jsessionId
94 ashish 629 
    args.write(self._oprot)
630 
    self._oprot.writeMessageEnd()
631 
    self._oprot.trans.flush()
632 
 
559 chandransh 633 
  def recv_createAnonymousUser(self, ):
94 ashish 634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
635 
    if mtype == TMessageType.EXCEPTION:
636 
      x = TApplicationException()
637 
      x.read(self._iprot)
638 
      self._iprot.readMessageEnd()
639 
      raise x
559 chandransh 640 
    result = createAnonymousUser_result()
94 ashish 641 
    result.read(self._iprot)
642 
    self._iprot.readMessageEnd()
643 
    if result.success != None:
644 
      return result.success
559 chandransh 645 
    if result.ucex != None:
646 
      raise result.ucex
647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 648 
 
559 chandransh 649 
  def getUserById(self, userId):
94 ashish 650 
    """
651 
    Parameters:
652 
     - userId
653 
    """
559 chandransh 654 
    self.send_getUserById(userId)
655 
    return self.recv_getUserById()
94 ashish 656 
 
559 chandransh 657 
  def send_getUserById(self, userId):
658 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
659 
    args = getUserById_args()
94 ashish 660 
    args.userId = userId
661 
    args.write(self._oprot)
662 
    self._oprot.writeMessageEnd()
663 
    self._oprot.trans.flush()
664 
 
559 chandransh 665 
  def recv_getUserById(self, ):
94 ashish 666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
667 
    if mtype == TMessageType.EXCEPTION:
668 
      x = TApplicationException()
669 
      x.read(self._iprot)
670 
      self._iprot.readMessageEnd()
671 
      raise x
559 chandransh 672 
    result = getUserById_result()
94 ashish 673 
    result.read(self._iprot)
674 
    self._iprot.readMessageEnd()
675 
    if result.success != None:
676 
      return result.success
559 chandransh 677 
    if result.ucex != None:
678 
      raise result.ucex
679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 680 
 
1491 vikas 681 
  def getUserByEmail(self, email):
682 
    """
683 
    Parameters:
684 
     - email
685 
    """
686 
    self.send_getUserByEmail(email)
687 
    return self.recv_getUserByEmail()
688 
 
689 
  def send_getUserByEmail(self, email):
690 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
691 
    args = getUserByEmail_args()
692 
    args.email = email
693 
    args.write(self._oprot)
694 
    self._oprot.writeMessageEnd()
695 
    self._oprot.trans.flush()
696 
 
697 
  def recv_getUserByEmail(self, ):
698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
699 
    if mtype == TMessageType.EXCEPTION:
700 
      x = TApplicationException()
701 
      x.read(self._iprot)
702 
      self._iprot.readMessageEnd()
703 
      raise x
704 
    result = getUserByEmail_result()
705 
    result.read(self._iprot)
706 
    self._iprot.readMessageEnd()
707 
    if result.success != None:
708 
      return result.success
709 
    if result.ucex != None:
710 
      raise result.ucex
711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
712 
 
3032 mandeep.dh 713 
  def getUserByMobileNumber(self, mobileNumber):
714 
    """
715 
    Parameters:
716 
     - mobileNumber
717 
    """
718 
    self.send_getUserByMobileNumber(mobileNumber)
719 
    return self.recv_getUserByMobileNumber()
720 
 
721 
  def send_getUserByMobileNumber(self, mobileNumber):
722 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
723 
    args = getUserByMobileNumber_args()
724 
    args.mobileNumber = mobileNumber
725 
    args.write(self._oprot)
726 
    self._oprot.writeMessageEnd()
727 
    self._oprot.trans.flush()
728 
 
729 
  def recv_getUserByMobileNumber(self, ):
730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
731 
    if mtype == TMessageType.EXCEPTION:
732 
      x = TApplicationException()
733 
      x.read(self._iprot)
734 
      self._iprot.readMessageEnd()
735 
      raise x
736 
    result = getUserByMobileNumber_result()
737 
    result.read(self._iprot)
738 
    self._iprot.readMessageEnd()
739 
    if result.success != None:
740 
      return result.success
741 
    if result.ucex != None:
742 
      raise result.ucex
743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
744 
 
559 chandransh 745 
  def createUser(self, user):
94 ashish 746 
    """
747 
    Parameters:
559 chandransh 748 
     - user
94 ashish 749 
    """
559 chandransh 750 
    self.send_createUser(user)
751 
    return self.recv_createUser()
94 ashish 752 
 
559 chandransh 753 
  def send_createUser(self, user):
754 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
755 
    args = createUser_args()
756 
    args.user = user
94 ashish 757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
559 chandransh 761 
  def recv_createUser(self, ):
94 ashish 762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
559 chandransh 768 
    result = createUser_result()
94 ashish 769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
771 
    if result.success != None:
772 
      return result.success
559 chandransh 773 
    if result.ucex != None:
774 
      raise result.ucex
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 776 
 
559 chandransh 777 
  def updateUser(self, user):
94 ashish 778 
    """
779 
    Parameters:
559 chandransh 780 
     - user
94 ashish 781 
    """
559 chandransh 782 
    self.send_updateUser(user)
783 
    return self.recv_updateUser()
94 ashish 784 
 
559 chandransh 785 
  def send_updateUser(self, user):
786 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
787 
    args = updateUser_args()
788 
    args.user = user
94 ashish 789 
    args.write(self._oprot)
790 
    self._oprot.writeMessageEnd()
791 
    self._oprot.trans.flush()
792 
 
559 chandransh 793 
  def recv_updateUser(self, ):
94 ashish 794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
795 
    if mtype == TMessageType.EXCEPTION:
796 
      x = TApplicationException()
797 
      x.read(self._iprot)
798 
      self._iprot.readMessageEnd()
799 
      raise x
559 chandransh 800 
    result = updateUser_result()
94 ashish 801 
    result.read(self._iprot)
802 
    self._iprot.readMessageEnd()
803 
    if result.success != None:
804 
      return result.success
559 chandransh 805 
    if result.ucex != None:
806 
      raise result.ucex
807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 808 
 
559 chandransh 809 
  def deleteUser(self, userId):
94 ashish 810 
    """
811 
    Parameters:
812 
     - userId
813 
    """
559 chandransh 814 
    self.send_deleteUser(userId)
815 
    return self.recv_deleteUser()
94 ashish 816 
 
559 chandransh 817 
  def send_deleteUser(self, userId):
818 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
819 
    args = deleteUser_args()
94 ashish 820 
    args.userId = userId
821 
    args.write(self._oprot)
822 
    self._oprot.writeMessageEnd()
823 
    self._oprot.trans.flush()
824 
 
559 chandransh 825 
  def recv_deleteUser(self, ):
94 ashish 826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
827 
    if mtype == TMessageType.EXCEPTION:
828 
      x = TApplicationException()
829 
      x.read(self._iprot)
830 
      self._iprot.readMessageEnd()
831 
      raise x
559 chandransh 832 
    result = deleteUser_result()
94 ashish 833 
    result.read(self._iprot)
834 
    self._iprot.readMessageEnd()
835 
    if result.success != None:
836 
      return result.success
559 chandransh 837 
    if result.ucex != None:
838 
      raise result.ucex
839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 840 
 
559 chandransh 841 
  def getUserState(self, userId):
94 ashish 842 
    """
843 
    Parameters:
844 
     - userId
845 
    """
559 chandransh 846 
    self.send_getUserState(userId)
847 
    return self.recv_getUserState()
94 ashish 848 
 
559 chandransh 849 
  def send_getUserState(self, userId):
850 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
851 
    args = getUserState_args()
94 ashish 852 
    args.userId = userId
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
559 chandransh 857 
  def recv_getUserState(self, ):
94 ashish 858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
559 chandransh 864 
    result = getUserState_result()
94 ashish 865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
867 
    if result.success != None:
868 
      return result.success
559 chandransh 869 
    if result.ucex != None:
870 
      raise result.ucex
871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 872 
 
559 chandransh 873 
  def authenticateUser(self, email, password):
94 ashish 874 
    """
875 
    Parameters:
876 
     - email
877 
     - password
878 
    """
559 chandransh 879 
    self.send_authenticateUser(email, password)
122 ashish 880 
    return self.recv_authenticateUser()
881 
 
559 chandransh 882 
  def send_authenticateUser(self, email, password):
122 ashish 883 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
884 
    args = authenticateUser_args()
559 chandransh 885 
    args.email = email
122 ashish 886 
    args.password = password
887 
    args.write(self._oprot)
888 
    self._oprot.writeMessageEnd()
889 
    self._oprot.trans.flush()
890 
 
891 
  def recv_authenticateUser(self, ):
892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
893 
    if mtype == TMessageType.EXCEPTION:
894 
      x = TApplicationException()
895 
      x.read(self._iprot)
896 
      self._iprot.readMessageEnd()
897 
      raise x
898 
    result = authenticateUser_result()
899 
    result.read(self._iprot)
900 
    self._iprot.readMessageEnd()
901 
    if result.success != None:
902 
      return result.success
559 chandransh 903 
    if result.auex != None:
904 
      raise result.auex
122 ashish 905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
906 
 
94 ashish 907 
  def userExists(self, email):
908 
    """
909 
    Parameters:
910 
     - email
911 
    """
912 
    self.send_userExists(email)
913 
    return self.recv_userExists()
914 
 
915 
  def send_userExists(self, email):
916 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
917 
    args = userExists_args()
918 
    args.email = email
919 
    args.write(self._oprot)
920 
    self._oprot.writeMessageEnd()
921 
    self._oprot.trans.flush()
922 
 
923 
  def recv_userExists(self, ):
924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
925 
    if mtype == TMessageType.EXCEPTION:
926 
      x = TApplicationException()
927 
      x.read(self._iprot)
928 
      self._iprot.readMessageEnd()
929 
      raise x
930 
    result = userExists_result()
931 
    result.read(self._iprot)
932 
    self._iprot.readMessageEnd()
933 
    if result.success != None:
934 
      return result.success
935 
    if result.ucx != None:
936 
      raise result.ucx
937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
938 
 
567 rajveer 939 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 940 
    """
941 
    Parameters:
942 
     - userId
943 
     - address
513 rajveer 944 
     - setDefault
94 ashish 945 
    """
567 rajveer 946 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 947 
    return self.recv_addAddressForUser()
948 
 
567 rajveer 949 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 950 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
951 
    args = addAddressForUser_args()
559 chandransh 952 
    args.userId = userId
94 ashish 953 
    args.address = address
513 rajveer 954 
    args.setDefault = setDefault
94 ashish 955 
    args.write(self._oprot)
956 
    self._oprot.writeMessageEnd()
957 
    self._oprot.trans.flush()
958 
 
959 
  def recv_addAddressForUser(self, ):
960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
961 
    if mtype == TMessageType.EXCEPTION:
962 
      x = TApplicationException()
963 
      x.read(self._iprot)
964 
      self._iprot.readMessageEnd()
965 
      raise x
966 
    result = addAddressForUser_result()
967 
    result.read(self._iprot)
968 
    self._iprot.readMessageEnd()
969 
    if result.success != None:
970 
      return result.success
971 
    if result.ucx != None:
972 
      raise result.ucx
973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
974 
 
975 
  def removeAddressForUser(self, userid, addressId):
976 
    """
977 
    Parameters:
978 
     - userid
979 
     - addressId
980 
    """
981 
    self.send_removeAddressForUser(userid, addressId)
982 
    return self.recv_removeAddressForUser()
983 
 
984 
  def send_removeAddressForUser(self, userid, addressId):
985 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
986 
    args = removeAddressForUser_args()
987 
    args.userid = userid
988 
    args.addressId = addressId
989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
993 
  def recv_removeAddressForUser(self, ):
994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
1000 
    result = removeAddressForUser_result()
1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
1003 
    if result.success != None:
1004 
      return result.success
1005 
    if result.ucx != None:
1006 
      raise result.ucx
1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1008 
 
1009 
  def setUserAsLoggedIn(self, userId, timestamp):
1010 
    """
1011 
    Parameters:
1012 
     - userId
1013 
     - timestamp
1014 
    """
1015 
    self.send_setUserAsLoggedIn(userId, timestamp)
1016 
    return self.recv_setUserAsLoggedIn()
1017 
 
1018 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1019 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1020 
    args = setUserAsLoggedIn_args()
1021 
    args.userId = userId
1022 
    args.timestamp = timestamp
1023 
    args.write(self._oprot)
1024 
    self._oprot.writeMessageEnd()
1025 
    self._oprot.trans.flush()
1026 
 
1027 
  def recv_setUserAsLoggedIn(self, ):
1028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1029 
    if mtype == TMessageType.EXCEPTION:
1030 
      x = TApplicationException()
1031 
      x.read(self._iprot)
1032 
      self._iprot.readMessageEnd()
1033 
      raise x
1034 
    result = setUserAsLoggedIn_result()
1035 
    result.read(self._iprot)
1036 
    self._iprot.readMessageEnd()
1037 
    if result.success != None:
1038 
      return result.success
1039 
    if result.ucx != None:
1040 
      raise result.ucx
1041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1042 
 
1043 
  def setUserAsLoggedOut(self, userid, timestamp):
1044 
    """
1045 
    Parameters:
1046 
     - userid
1047 
     - timestamp
1048 
    """
1049 
    self.send_setUserAsLoggedOut(userid, timestamp)
1050 
    return self.recv_setUserAsLoggedOut()
1051 
 
1052 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1053 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1054 
    args = setUserAsLoggedOut_args()
1055 
    args.userid = userid
1056 
    args.timestamp = timestamp
1057 
    args.write(self._oprot)
1058 
    self._oprot.writeMessageEnd()
1059 
    self._oprot.trans.flush()
1060 
 
1061 
  def recv_setUserAsLoggedOut(self, ):
1062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1063 
    if mtype == TMessageType.EXCEPTION:
1064 
      x = TApplicationException()
1065 
      x.read(self._iprot)
1066 
      self._iprot.readMessageEnd()
1067 
      raise x
1068 
    result = setUserAsLoggedOut_result()
1069 
    result.read(self._iprot)
1070 
    self._iprot.readMessageEnd()
1071 
    if result.success != None:
1072 
      return result.success
1073 
    if result.ucx != None:
1074 
      raise result.ucx
1075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1076 
 
504 rajveer 1077 
  def setDefaultAddress(self, userid, addressId):
1078 
    """
1079 
    Parameters:
1080 
     - userid
1081 
     - addressId
1082 
    """
1083 
    self.send_setDefaultAddress(userid, addressId)
1084 
    return self.recv_setDefaultAddress()
1085 
 
1086 
  def send_setDefaultAddress(self, userid, addressId):
1087 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1088 
    args = setDefaultAddress_args()
1089 
    args.userid = userid
1090 
    args.addressId = addressId
1091 
    args.write(self._oprot)
1092 
    self._oprot.writeMessageEnd()
1093 
    self._oprot.trans.flush()
1094 
 
1095 
  def recv_setDefaultAddress(self, ):
1096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1097 
    if mtype == TMessageType.EXCEPTION:
1098 
      x = TApplicationException()
1099 
      x.read(self._iprot)
1100 
      self._iprot.readMessageEnd()
1101 
      raise x
1102 
    result = setDefaultAddress_result()
1103 
    result.read(self._iprot)
1104 
    self._iprot.readMessageEnd()
1105 
    if result.success != None:
1106 
      return result.success
1107 
    if result.ucx != None:
1108 
      raise result.ucx
1109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1110 
 
594 rajveer 1111 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1112 
    """
1113 
    Parameters:
1114 
     - userid
594 rajveer 1115 
     - oldPassword
1116 
     - newPassword
94 ashish 1117 
    """
594 rajveer 1118 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1119 
    return self.recv_updatePassword()
1120 
 
594 rajveer 1121 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1122 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1123 
    args = updatePassword_args()
1124 
    args.userid = userid
594 rajveer 1125 
    args.oldPassword = oldPassword
1126 
    args.newPassword = newPassword
94 ashish 1127 
    args.write(self._oprot)
1128 
    self._oprot.writeMessageEnd()
1129 
    self._oprot.trans.flush()
1130 
 
1131 
  def recv_updatePassword(self, ):
1132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1133 
    if mtype == TMessageType.EXCEPTION:
1134 
      x = TApplicationException()
1135 
      x.read(self._iprot)
1136 
      self._iprot.readMessageEnd()
1137 
      raise x
1138 
    result = updatePassword_result()
1139 
    result.read(self._iprot)
1140 
    self._iprot.readMessageEnd()
1141 
    if result.success != None:
1142 
      return result.success
1143 
    if result.ucx != None:
1144 
      raise result.ucx
1145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1146 
 
884 rajveer 1147 
  def forgotPassword(self, email, newPassword):
581 rajveer 1148 
    """
1149 
    Parameters:
1150 
     - email
884 rajveer 1151 
     - newPassword
581 rajveer 1152 
    """
884 rajveer 1153 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1154 
    return self.recv_forgotPassword()
1155 
 
884 rajveer 1156 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1157 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1158 
    args = forgotPassword_args()
1159 
    args.email = email
884 rajveer 1160 
    args.newPassword = newPassword
581 rajveer 1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_forgotPassword(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = forgotPassword_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
1175 
    if result.success != None:
1176 
      return result.success
1177 
    if result.ucx != None:
1178 
      raise result.ucx
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1180 
 
594 rajveer 1181 
  def getAllAddressesForUser(self, userId):
1182 
    """
1183 
    Parameters:
1184 
     - userId
1185 
    """
1186 
    self.send_getAllAddressesForUser(userId)
1187 
    return self.recv_getAllAddressesForUser()
1188 
 
1189 
  def send_getAllAddressesForUser(self, userId):
1190 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1191 
    args = getAllAddressesForUser_args()
1192 
    args.userId = userId
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getAllAddressesForUser(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getAllAddressesForUser_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success != None:
1208 
      return result.success
1209 
    if result.ucx != None:
1210 
      raise result.ucx
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1212 
 
1894 vikas 1213 
  def getAddressById(self, addressId):
1214 
    """
1215 
    Parameters:
1216 
     - addressId
1217 
    """
1218 
    self.send_getAddressById(addressId)
1219 
    return self.recv_getAddressById()
1220 
 
1221 
  def send_getAddressById(self, addressId):
1222 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1223 
    args = getAddressById_args()
1224 
    args.addressId = addressId
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_getAddressById(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = getAddressById_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
1239 
    if result.success != None:
1240 
      return result.success
1241 
    if result.ucx != None:
1242 
      raise result.ucx
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1244 
 
594 rajveer 1245 
  def getDefaultAddressId(self, userId):
1246 
    """
1247 
    Parameters:
1248 
     - userId
1249 
    """
1250 
    self.send_getDefaultAddressId(userId)
1251 
    return self.recv_getDefaultAddressId()
1252 
 
1253 
  def send_getDefaultAddressId(self, userId):
1254 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1255 
    args = getDefaultAddressId_args()
1256 
    args.userId = userId
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getDefaultAddressId(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getDefaultAddressId_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
1271 
    if result.success != None:
1272 
      return result.success
1273 
    if result.ucx != None:
1274 
      raise result.ucx
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1276 
 
785 rajveer 1277 
  def getDefaultPincode(self, userId):
1278 
    """
1279 
    Parameters:
1280 
     - userId
1281 
    """
1282 
    self.send_getDefaultPincode(userId)
1283 
    return self.recv_getDefaultPincode()
1284 
 
1285 
  def send_getDefaultPincode(self, userId):
1286 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1287 
    args = getDefaultPincode_args()
1288 
    args.userId = userId
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getDefaultPincode(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getDefaultPincode_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.success != None:
1304 
      return result.success
1305 
    if result.ucx != None:
1306 
      raise result.ucx
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1308 
 
1274 varun.gupt 1309 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1310 
    """
1311 
    Parameters:
1312 
     - userId
1313 
     - replyTo
1314 
     - communicationType
1315 
     - orderId
1316 
     - airwaybillNo
1317 
     - productName
1318 
     - subject
1319 
     - message
1320 
    """
1321 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1322 
    return self.recv_saveUserCommunication()
1323 
 
1324 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1325 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1326 
    args = saveUserCommunication_args()
1327 
    args.userId = userId
1328 
    args.replyTo = replyTo
1329 
    args.communicationType = communicationType
1330 
    args.orderId = orderId
1331 
    args.airwaybillNo = airwaybillNo
1332 
    args.productName = productName
1333 
    args.subject = subject
1334 
    args.message = message
1335 
    args.write(self._oprot)
1336 
    self._oprot.writeMessageEnd()
1337 
    self._oprot.trans.flush()
1338 
 
1339 
  def recv_saveUserCommunication(self, ):
1340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1341 
    if mtype == TMessageType.EXCEPTION:
1342 
      x = TApplicationException()
1343 
      x.read(self._iprot)
1344 
      self._iprot.readMessageEnd()
1345 
      raise x
1346 
    result = saveUserCommunication_result()
1347 
    result.read(self._iprot)
1348 
    self._iprot.readMessageEnd()
1349 
    if result.success != None:
1350 
      return result.success
1351 
    if result.ucx != None:
1352 
      raise result.ucx
1353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1354 
 
1590 varun.gupt 1355 
  def getUserCommunicationById(self, id):
1356 
    """
1357 
    Parameters:
1358 
     - id
1359 
    """
1360 
    self.send_getUserCommunicationById(id)
1361 
    return self.recv_getUserCommunicationById()
1362 
 
1363 
  def send_getUserCommunicationById(self, id):
1364 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1365 
    args = getUserCommunicationById_args()
1366 
    args.id = id
1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
1371 
  def recv_getUserCommunicationById(self, ):
1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1373 
    if mtype == TMessageType.EXCEPTION:
1374 
      x = TApplicationException()
1375 
      x.read(self._iprot)
1376 
      self._iprot.readMessageEnd()
1377 
      raise x
1378 
    result = getUserCommunicationById_result()
1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
1381 
    if result.success != None:
1382 
      return result.success
1383 
    if result.ucx != None:
1384 
      raise result.ucx
1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1386 
 
1387 
  def getUserCommunicationByUser(self, userId):
1388 
    """
1389 
    Parameters:
1390 
     - userId
1391 
    """
1392 
    self.send_getUserCommunicationByUser(userId)
1393 
    return self.recv_getUserCommunicationByUser()
1394 
 
1395 
  def send_getUserCommunicationByUser(self, userId):
1396 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1397 
    args = getUserCommunicationByUser_args()
1398 
    args.userId = userId
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getUserCommunicationByUser(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getUserCommunicationByUser_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
1413 
    if result.success != None:
1414 
      return result.success
1415 
    if result.ucx != None:
1416 
      raise result.ucx
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1418 
 
1419 
  def getAllUserCommunications(self, ):
1420 
    self.send_getAllUserCommunications()
1421 
    return self.recv_getAllUserCommunications()
1422 
 
1423 
  def send_getAllUserCommunications(self, ):
1424 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1425 
    args = getAllUserCommunications_args()
1426 
    args.write(self._oprot)
1427 
    self._oprot.writeMessageEnd()
1428 
    self._oprot.trans.flush()
1429 
 
1430 
  def recv_getAllUserCommunications(self, ):
1431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1432 
    if mtype == TMessageType.EXCEPTION:
1433 
      x = TApplicationException()
1434 
      x.read(self._iprot)
1435 
      self._iprot.readMessageEnd()
1436 
      raise x
1437 
    result = getAllUserCommunications_result()
1438 
    result.read(self._iprot)
1439 
    self._iprot.readMessageEnd()
1440 
    if result.success != None:
1441 
      return result.success
1442 
    if result.ucx != None:
1443 
      raise result.ucx
1444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1445 
 
1859 vikas 1446 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1447 
    """
1448 
    Parameters:
1449 
     - name
1859 vikas 1450 
     - addedOn
1845 vikas 1451 
    """
1859 vikas 1452 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1453 
    return self.recv_createMasterAffiliate()
1454 
 
1859 vikas 1455 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1456 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1457 
    args = createMasterAffiliate_args()
1458 
    args.name = name
1859 vikas 1459 
    args.addedOn = addedOn
1845 vikas 1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1464 
  def recv_createMasterAffiliate(self, ):
1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1471 
    result = createMasterAffiliate_result()
1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
1474 
    if result.success != None:
1475 
      return result.success
1476 
    if result.utx != None:
1477 
      raise result.utx
1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1479 
 
1899 vikas 1480 
  def getAllMasterAffiliates(self, ):
1481 
    self.send_getAllMasterAffiliates()
1482 
    return self.recv_getAllMasterAffiliates()
1483 
 
1484 
  def send_getAllMasterAffiliates(self, ):
1485 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1486 
    args = getAllMasterAffiliates_args()
1487 
    args.write(self._oprot)
1488 
    self._oprot.writeMessageEnd()
1489 
    self._oprot.trans.flush()
1490 
 
1491 
  def recv_getAllMasterAffiliates(self, ):
1492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1493 
    if mtype == TMessageType.EXCEPTION:
1494 
      x = TApplicationException()
1495 
      x.read(self._iprot)
1496 
      self._iprot.readMessageEnd()
1497 
      raise x
1498 
    result = getAllMasterAffiliates_result()
1499 
    result.read(self._iprot)
1500 
    self._iprot.readMessageEnd()
1501 
    if result.success != None:
1502 
      return result.success
1503 
    if result.utx != None:
1504 
      raise result.utx
1505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1506 
 
1845 vikas 1507 
  def getMasterAffiliateById(self, id):
1508 
    """
1509 
    Parameters:
1510 
     - id
1511 
    """
1512 
    self.send_getMasterAffiliateById(id)
1513 
    return self.recv_getMasterAffiliateById()
1514 
 
1515 
  def send_getMasterAffiliateById(self, id):
1516 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1517 
    args = getMasterAffiliateById_args()
1518 
    args.id = id
1519 
    args.write(self._oprot)
1520 
    self._oprot.writeMessageEnd()
1521 
    self._oprot.trans.flush()
1522 
 
1523 
  def recv_getMasterAffiliateById(self, ):
1524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1525 
    if mtype == TMessageType.EXCEPTION:
1526 
      x = TApplicationException()
1527 
      x.read(self._iprot)
1528 
      self._iprot.readMessageEnd()
1529 
      raise x
1530 
    result = getMasterAffiliateById_result()
1531 
    result.read(self._iprot)
1532 
    self._iprot.readMessageEnd()
1533 
    if result.success != None:
1534 
      return result.success
1535 
    if result.utx != None:
1536 
      raise result.utx
1537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1538 
 
1539 
  def getMasterAffiliateByName(self, name):
1540 
    """
1541 
    Parameters:
1542 
     - name
1543 
    """
1544 
    self.send_getMasterAffiliateByName(name)
1545 
    return self.recv_getMasterAffiliateByName()
1546 
 
1547 
  def send_getMasterAffiliateByName(self, name):
1548 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1549 
    args = getMasterAffiliateByName_args()
1550 
    args.name = name
1551 
    args.write(self._oprot)
1552 
    self._oprot.writeMessageEnd()
1553 
    self._oprot.trans.flush()
1554 
 
1555 
  def recv_getMasterAffiliateByName(self, ):
1556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1557 
    if mtype == TMessageType.EXCEPTION:
1558 
      x = TApplicationException()
1559 
      x.read(self._iprot)
1560 
      self._iprot.readMessageEnd()
1561 
      raise x
1562 
    result = getMasterAffiliateByName_result()
1563 
    result.read(self._iprot)
1564 
    self._iprot.readMessageEnd()
1565 
    if result.success != None:
1566 
      return result.success
1567 
    if result.utx != None:
1568 
      raise result.utx
1569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1570 
 
1859 vikas 1571 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1572 
    """
1573 
    Parameters:
1574 
     - name
1575 
     - url
1576 
     - masterAffiliateId
1859 vikas 1577 
     - addedOn
1845 vikas 1578 
    """
1859 vikas 1579 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1580 
    return self.recv_createAffiliate()
1581 
 
1859 vikas 1582 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1583 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1584 
    args = createAffiliate_args()
1585 
    args.name = name
1586 
    args.url = url
1587 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1588 
    args.addedOn = addedOn
1845 vikas 1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_createAffiliate(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = createAffiliate_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
1603 
    if result.success != None:
1604 
      return result.success
1605 
    if result.utx != None:
1606 
      raise result.utx
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1608 
 
1609 
  def getAffiliateById(self, id):
1610 
    """
1611 
    Parameters:
1612 
     - id
1613 
    """
1614 
    self.send_getAffiliateById(id)
1615 
    return self.recv_getAffiliateById()
1616 
 
1617 
  def send_getAffiliateById(self, id):
1618 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1619 
    args = getAffiliateById_args()
1620 
    args.id = id
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getAffiliateById(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getAffiliateById_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
1635 
    if result.success != None:
1636 
      return result.success
1637 
    if result.utx != None:
1638 
      raise result.utx
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1640 
 
1641 
  def getAffiliateByName(self, name):
1642 
    """
1643 
    Parameters:
1644 
     - name
1645 
    """
1646 
    self.send_getAffiliateByName(name)
1647 
    return self.recv_getAffiliateByName()
1648 
 
1649 
  def send_getAffiliateByName(self, name):
1650 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1651 
    args = getAffiliateByName_args()
1652 
    args.name = name
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getAffiliateByName(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getAffiliateByName_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    if result.success != None:
1668 
      return result.success
1669 
    if result.utx != None:
1670 
      raise result.utx
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1672 
 
1996 vikas 1673 
  def getTrackerById(self, id):
1845 vikas 1674 
    """
1675 
    Parameters:
1676 
     - id
1677 
    """
1996 vikas 1678 
    self.send_getTrackerById(id)
1845 vikas 1679 
    return self.recv_getTrackerById()
1680 
 
1996 vikas 1681 
  def send_getTrackerById(self, id):
1845 vikas 1682 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1683 
    args = getTrackerById_args()
1996 vikas 1684 
    args.id = id
1845 vikas 1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1689 
  def recv_getTrackerById(self, ):
1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1696 
    result = getTrackerById_result()
1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
1699 
    if result.success != None:
1700 
      return result.success
1701 
    if result.utx != None:
1702 
      raise result.utx
1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1704 
 
1996 vikas 1705 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1706 
    """
1707 
    Parameters:
1996 vikas 1708 
     - id
1845 vikas 1709 
    """
1996 vikas 1710 
    self.send_getAffiliatesByMasterAffiliate(id)
1711 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1712 
 
1996 vikas 1713 
  def send_getAffiliatesByMasterAffiliate(self, id):
1714 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1715 
    args = getAffiliatesByMasterAffiliate_args()
1716 
    args.id = id
1845 vikas 1717 
    args.write(self._oprot)
1718 
    self._oprot.writeMessageEnd()
1719 
    self._oprot.trans.flush()
1720 
 
1996 vikas 1721 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1723 
    if mtype == TMessageType.EXCEPTION:
1724 
      x = TApplicationException()
1725 
      x.read(self._iprot)
1726 
      self._iprot.readMessageEnd()
1727 
      raise x
1996 vikas 1728 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1729 
    result.read(self._iprot)
1730 
    self._iprot.readMessageEnd()
1731 
    if result.success != None:
1732 
      return result.success
1733 
    if result.utx != None:
1734 
      raise result.utx
1996 vikas 1735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1736 
 
1996 vikas 1737 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1738 
    """
1739 
    Parameters:
1996 vikas 1740 
     - affiliateId
1845 vikas 1741 
     - userId
1742 
     - event
1743 
     - url
1744 
     - data
1859 vikas 1745 
     - addedOn
1845 vikas 1746 
    """
1996 vikas 1747 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1748 
    return self.recv_addTrackLog()
1749 
 
1996 vikas 1750 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1751 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1752 
    args = addTrackLog_args()
1996 vikas 1753 
    args.affiliateId = affiliateId
1845 vikas 1754 
    args.userId = userId
1755 
    args.event = event
1756 
    args.url = url
1757 
    args.data = data
1859 vikas 1758 
    args.addedOn = addedOn
1845 vikas 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_addTrackLog(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = addTrackLog_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success != None:
1774 
      return result.success
1775 
    if result.utx != None:
1776 
      raise result.utx
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1778 
 
1779 
  def getTrackLogById(self, id):
1780 
    """
1781 
    Parameters:
1782 
     - id
1783 
    """
1784 
    self.send_getTrackLogById(id)
1785 
    return self.recv_getTrackLogById()
1786 
 
1787 
  def send_getTrackLogById(self, id):
1788 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1789 
    args = getTrackLogById_args()
1790 
    args.id = id
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getTrackLogById(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getTrackLogById_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    if result.success != None:
1806 
      return result.success
1807 
    if result.utx != None:
1808 
      raise result.utx
1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1810 
 
1996 vikas 1811 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1812 
    """
1813 
    Parameters:
1996 vikas 1814 
     - affiliateId
1845 vikas 1815 
    """
1996 vikas 1816 
    self.send_getTrackLogsByAffiliate(affiliateId)
1817 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1818 
 
1996 vikas 1819 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1820 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1821 
    args = getTrackLogsByAffiliate_args()
1822 
    args.affiliateId = affiliateId
1845 vikas 1823 
    args.write(self._oprot)
1824 
    self._oprot.writeMessageEnd()
1825 
    self._oprot.trans.flush()
1826 
 
1996 vikas 1827 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1829 
    if mtype == TMessageType.EXCEPTION:
1830 
      x = TApplicationException()
1831 
      x.read(self._iprot)
1832 
      self._iprot.readMessageEnd()
1833 
      raise x
1996 vikas 1834 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1835 
    result.read(self._iprot)
1836 
    self._iprot.readMessageEnd()
1837 
    if result.success != None:
1838 
      return result.success
1839 
    if result.utx != None:
1840 
      raise result.utx
1996 vikas 1841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1842 
 
1843 
  def getTrackLogsByUser(self, userId):
1844 
    """
1845 
    Parameters:
1846 
     - userId
1847 
    """
1848 
    self.send_getTrackLogsByUser(userId)
1849 
    return self.recv_getTrackLogsByUser()
1850 
 
1851 
  def send_getTrackLogsByUser(self, userId):
1852 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1853 
    args = getTrackLogsByUser_args()
1854 
    args.userId = userId
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getTrackLogsByUser(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = getTrackLogsByUser_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
1869 
    if result.success != None:
1870 
      return result.success
1871 
    if result.utx != None:
1872 
      raise result.utx
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1874 
 
1996 vikas 1875 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1876 
    """
1877 
    Parameters:
1878 
     - userId
1879 
     - event
1880 
     - url
1881 
    """
1996 vikas 1882 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1883 
    return self.recv_getTrackLogs()
1884 
 
1996 vikas 1885 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1886 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1887 
    args = getTrackLogs_args()
1888 
    args.userId = userId
1889 
    args.event = event
1890 
    args.url = url
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getTrackLogs(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getTrackLogs_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
1905 
    if result.success != None:
1906 
      return result.success
1907 
    if result.utx != None:
1908 
      raise result.utx
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1910 
 
559 chandransh 1911 
  def createCart(self, userId):
94 ashish 1912 
    """
1913 
    Parameters:
559 chandransh 1914 
     - userId
94 ashish 1915 
    """
559 chandransh 1916 
    self.send_createCart(userId)
1917 
    return self.recv_createCart()
94 ashish 1918 
 
559 chandransh 1919 
  def send_createCart(self, userId):
1920 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1921 
    args = createCart_args()
1922 
    args.userId = userId
94 ashish 1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
559 chandransh 1927 
  def recv_createCart(self, ):
94 ashish 1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
559 chandransh 1934 
    result = createCart_result()
94 ashish 1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
1937 
    if result.success != None:
1938 
      return result.success
559 chandransh 1939 
    if result.scx != None:
1940 
      raise result.scx
1941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1942 
 
559 chandransh 1943 
  def getCurrentCart(self, userId):
94 ashish 1944 
    """
1945 
    Parameters:
559 chandransh 1946 
     - userId
94 ashish 1947 
    """
559 chandransh 1948 
    self.send_getCurrentCart(userId)
1949 
    return self.recv_getCurrentCart()
94 ashish 1950 
 
559 chandransh 1951 
  def send_getCurrentCart(self, userId):
1952 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1953 
    args = getCurrentCart_args()
1954 
    args.userId = userId
94 ashish 1955 
    args.write(self._oprot)
1956 
    self._oprot.writeMessageEnd()
1957 
    self._oprot.trans.flush()
1958 
 
559 chandransh 1959 
  def recv_getCurrentCart(self, ):
94 ashish 1960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1961 
    if mtype == TMessageType.EXCEPTION:
1962 
      x = TApplicationException()
1963 
      x.read(self._iprot)
1964 
      self._iprot.readMessageEnd()
1965 
      raise x
559 chandransh 1966 
    result = getCurrentCart_result()
94 ashish 1967 
    result.read(self._iprot)
1968 
    self._iprot.readMessageEnd()
1969 
    if result.success != None:
1970 
      return result.success
559 chandransh 1971 
    if result.scx != None:
1972 
      raise result.scx
1973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1974 
 
559 chandransh 1975 
  def getCart(self, cartId):
94 ashish 1976 
    """
1977 
    Parameters:
559 chandransh 1978 
     - cartId
94 ashish 1979 
    """
559 chandransh 1980 
    self.send_getCart(cartId)
1981 
    return self.recv_getCart()
94 ashish 1982 
 
559 chandransh 1983 
  def send_getCart(self, cartId):
1984 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1985 
    args = getCart_args()
1986 
    args.cartId = cartId
94 ashish 1987 
    args.write(self._oprot)
1988 
    self._oprot.writeMessageEnd()
1989 
    self._oprot.trans.flush()
1990 
 
559 chandransh 1991 
  def recv_getCart(self, ):
94 ashish 1992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1993 
    if mtype == TMessageType.EXCEPTION:
1994 
      x = TApplicationException()
1995 
      x.read(self._iprot)
1996 
      self._iprot.readMessageEnd()
1997 
      raise x
559 chandransh 1998 
    result = getCart_result()
94 ashish 1999 
    result.read(self._iprot)
2000 
    self._iprot.readMessageEnd()
2001 
    if result.success != None:
2002 
      return result.success
559 chandransh 2003 
    if result.scx != None:
2004 
      raise result.scx
2005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2006 
 
559 chandransh 2007 
  def getCartsForUser(self, userId, status):
94 ashish 2008 
    """
2009 
    Parameters:
559 chandransh 2010 
     - userId
2011 
     - status
94 ashish 2012 
    """
559 chandransh 2013 
    self.send_getCartsForUser(userId, status)
2014 
    return self.recv_getCartsForUser()
94 ashish 2015 
 
559 chandransh 2016 
  def send_getCartsForUser(self, userId, status):
2017 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
2018 
    args = getCartsForUser_args()
2019 
    args.userId = userId
2020 
    args.status = status
94 ashish 2021 
    args.write(self._oprot)
2022 
    self._oprot.writeMessageEnd()
2023 
    self._oprot.trans.flush()
2024 
 
559 chandransh 2025 
  def recv_getCartsForUser(self, ):
94 ashish 2026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2027 
    if mtype == TMessageType.EXCEPTION:
2028 
      x = TApplicationException()
2029 
      x.read(self._iprot)
2030 
      self._iprot.readMessageEnd()
2031 
      raise x
559 chandransh 2032 
    result = getCartsForUser_result()
94 ashish 2033 
    result.read(self._iprot)
2034 
    self._iprot.readMessageEnd()
2035 
    if result.success != None:
2036 
      return result.success
559 chandransh 2037 
    if result.scx != None:
2038 
      raise result.scx
2039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2040 
 
559 chandransh 2041 
  def getCartsByStatus(self, status):
94 ashish 2042 
    """
2043 
    Parameters:
559 chandransh 2044 
     - status
94 ashish 2045 
    """
559 chandransh 2046 
    self.send_getCartsByStatus(status)
2047 
    return self.recv_getCartsByStatus()
94 ashish 2048 
 
559 chandransh 2049 
  def send_getCartsByStatus(self, status):
2050 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2051 
    args = getCartsByStatus_args()
2052 
    args.status = status
94 ashish 2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
559 chandransh 2057 
  def recv_getCartsByStatus(self, ):
94 ashish 2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
559 chandransh 2064 
    result = getCartsByStatus_result()
94 ashish 2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
2067 
    if result.success != None:
2068 
      return result.success
559 chandransh 2069 
    if result.scx != None:
2070 
      raise result.scx
2071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2072 
 
559 chandransh 2073 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2074 
    """
2075 
    Parameters:
559 chandransh 2076 
     - from_time
2077 
     - to_time
2078 
     - status
94 ashish 2079 
    """
559 chandransh 2080 
    self.send_getCartsByTime(from_time, to_time, status)
2081 
    return self.recv_getCartsByTime()
94 ashish 2082 
 
559 chandransh 2083 
  def send_getCartsByTime(self, from_time, to_time, status):
2084 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2085 
    args = getCartsByTime_args()
2086 
    args.from_time = from_time
2087 
    args.to_time = to_time
2088 
    args.status = status
94 ashish 2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
559 chandransh 2093 
  def recv_getCartsByTime(self, ):
94 ashish 2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
559 chandransh 2100 
    result = getCartsByTime_result()
94 ashish 2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
2103 
    if result.success != None:
2104 
      return result.success
559 chandransh 2105 
    if result.scx != None:
2106 
      raise result.scx
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2108 
 
559 chandransh 2109 
  def changeCartStatus(self, cartId, status):
130 ashish 2110 
    """
2111 
    Parameters:
559 chandransh 2112 
     - cartId
2113 
     - status
130 ashish 2114 
    """
559 chandransh 2115 
    self.send_changeCartStatus(cartId, status)
2116 
    self.recv_changeCartStatus()
94 ashish 2117 
 
559 chandransh 2118 
  def send_changeCartStatus(self, cartId, status):
2119 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2120 
    args = changeCartStatus_args()
2121 
    args.cartId = cartId
2122 
    args.status = status
130 ashish 2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
559 chandransh 2127 
  def recv_changeCartStatus(self, ):
130 ashish 2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
559 chandransh 2134 
    result = changeCartStatus_result()
130 ashish 2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
559 chandransh 2137 
    if result.scx != None:
2138 
      raise result.scx
2139 
    return
2140 
 
2141 
  def addItemToCart(self, cartId, itemId, quantity):
2142 
    """
2143 
    Parameters:
2144 
     - cartId
2145 
     - itemId
2146 
     - quantity
2147 
    """
2148 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2149 
    return self.recv_addItemToCart()
559 chandransh 2150 
 
2151 
  def send_addItemToCart(self, cartId, itemId, quantity):
2152 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2153 
    args = addItemToCart_args()
2154 
    args.cartId = cartId
2155 
    args.itemId = itemId
2156 
    args.quantity = quantity
2157 
    args.write(self._oprot)
2158 
    self._oprot.writeMessageEnd()
2159 
    self._oprot.trans.flush()
2160 
 
2161 
  def recv_addItemToCart(self, ):
2162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2163 
    if mtype == TMessageType.EXCEPTION:
2164 
      x = TApplicationException()
2165 
      x.read(self._iprot)
2166 
      self._iprot.readMessageEnd()
2167 
      raise x
2168 
    result = addItemToCart_result()
2169 
    result.read(self._iprot)
2170 
    self._iprot.readMessageEnd()
2035 rajveer 2171 
    if result.success != None:
2172 
      return result.success
559 chandransh 2173 
    if result.scx != None:
2174 
      raise result.scx
2035 rajveer 2175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2176 
 
2177 
  def deleteItemFromCart(self, cartId, itemId):
2178 
    """
2179 
    Parameters:
2180 
     - cartId
2181 
     - itemId
2182 
    """
2183 
    self.send_deleteItemFromCart(cartId, itemId)
2184 
    self.recv_deleteItemFromCart()
2185 
 
2186 
  def send_deleteItemFromCart(self, cartId, itemId):
2187 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2188 
    args = deleteItemFromCart_args()
2189 
    args.cartId = cartId
2190 
    args.itemId = itemId
2191 
    args.write(self._oprot)
2192 
    self._oprot.writeMessageEnd()
2193 
    self._oprot.trans.flush()
2194 
 
2195 
  def recv_deleteItemFromCart(self, ):
2196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2197 
    if mtype == TMessageType.EXCEPTION:
2198 
      x = TApplicationException()
2199 
      x.read(self._iprot)
2200 
      self._iprot.readMessageEnd()
2201 
      raise x
2202 
    result = deleteItemFromCart_result()
2203 
    result.read(self._iprot)
2204 
    self._iprot.readMessageEnd()
2205 
    if result.scx != None:
2206 
      raise result.scx
2207 
    return
2208 
 
2209 
  def changeQuantity(self, cartId, itemId, quantity):
2210 
    """
2211 
    Parameters:
2212 
     - cartId
2213 
     - itemId
2214 
     - quantity
2215 
    """
2216 
    self.send_changeQuantity(cartId, itemId, quantity)
2217 
    self.recv_changeQuantity()
2218 
 
2219 
  def send_changeQuantity(self, cartId, itemId, quantity):
2220 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2221 
    args = changeQuantity_args()
2222 
    args.cartId = cartId
2223 
    args.itemId = itemId
2224 
    args.quantity = quantity
2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
2229 
  def recv_changeQuantity(self, ):
2230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2231 
    if mtype == TMessageType.EXCEPTION:
2232 
      x = TApplicationException()
2233 
      x.read(self._iprot)
2234 
      self._iprot.readMessageEnd()
2235 
      raise x
2236 
    result = changeQuantity_result()
2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
2239 
    if result.scx != None:
2240 
      raise result.scx
2241 
    return
2242 
 
2243 
  def changeItemStatus(self, cartId, itemId, status):
2244 
    """
2245 
    Parameters:
2246 
     - cartId
2247 
     - itemId
2248 
     - status
2249 
    """
2250 
    self.send_changeItemStatus(cartId, itemId, status)
2251 
    self.recv_changeItemStatus()
2252 
 
2253 
  def send_changeItemStatus(self, cartId, itemId, status):
2254 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2255 
    args = changeItemStatus_args()
2256 
    args.cartId = cartId
2257 
    args.itemId = itemId
2258 
    args.status = status
2259 
    args.write(self._oprot)
2260 
    self._oprot.writeMessageEnd()
2261 
    self._oprot.trans.flush()
2262 
 
2263 
  def recv_changeItemStatus(self, ):
2264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2265 
    if mtype == TMessageType.EXCEPTION:
2266 
      x = TApplicationException()
2267 
      x.read(self._iprot)
2268 
      self._iprot.readMessageEnd()
2269 
      raise x
2270 
    result = changeItemStatus_result()
2271 
    result.read(self._iprot)
2272 
    self._iprot.readMessageEnd()
2273 
    if result.scx != None:
2274 
      raise result.scx
2275 
    return
2276 
 
2277 
  def addAddressToCart(self, cartId, addressId):
2278 
    """
2279 
    Parameters:
2280 
     - cartId
2281 
     - addressId
2282 
    """
2283 
    self.send_addAddressToCart(cartId, addressId)
2284 
    self.recv_addAddressToCart()
2285 
 
2286 
  def send_addAddressToCart(self, cartId, addressId):
2287 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2288 
    args = addAddressToCart_args()
2289 
    args.cartId = cartId
2290 
    args.addressId = addressId
2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_addAddressToCart(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = addAddressToCart_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
575 chandransh 2305 
    if result.scx != None:
2306 
      raise result.scx
559 chandransh 2307 
    return
2308 
 
1976 varun.gupt 2309 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2310 
    """
2311 
    Parameters:
2312 
     - cartId
2313 
     - couponCode
2314 
     - totalPrice
2315 
     - discountedPrice
2316 
    """
2317 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2318 
    self.recv_applyCouponToCart()
2319 
 
2320 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2321 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2322 
    args = applyCouponToCart_args()
2323 
    args.cartId = cartId
2324 
    args.couponCode = couponCode
2325 
    args.totalPrice = totalPrice
2326 
    args.discountedPrice = discountedPrice
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_applyCouponToCart(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = applyCouponToCart_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
2341 
    if result.scx != None:
2342 
      raise result.scx
2343 
    return
2344 
 
2345 
  def removeCoupon(self, cartId):
2346 
    """
2347 
    Parameters:
2348 
     - cartId
2349 
    """
2350 
    self.send_removeCoupon(cartId)
2351 
    self.recv_removeCoupon()
2352 
 
2353 
  def send_removeCoupon(self, cartId):
2354 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2355 
    args = removeCoupon_args()
2356 
    args.cartId = cartId
2357 
    args.write(self._oprot)
2358 
    self._oprot.writeMessageEnd()
2359 
    self._oprot.trans.flush()
2360 
 
2361 
  def recv_removeCoupon(self, ):
2362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2363 
    if mtype == TMessageType.EXCEPTION:
2364 
      x = TApplicationException()
2365 
      x.read(self._iprot)
2366 
      self._iprot.readMessageEnd()
2367 
      raise x
2368 
    result = removeCoupon_result()
2369 
    result.read(self._iprot)
2370 
    self._iprot.readMessageEnd()
2371 
    if result.scx != None:
2372 
      raise result.scx
2373 
    return
2374 
 
2815 vikas 2375 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2376 
    """
690 chandransh 2377 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2378 
 
559 chandransh 2379 
    Parameters:
2380 
     - cartId
2815 vikas 2381 
     - sessionSource
2382 
     - sessionStartTime
559 chandransh 2383 
    """
2815 vikas 2384 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2385 
    return self.recv_createOrders()
559 chandransh 2386 
 
2815 vikas 2387 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2388 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2389 
    args = createOrders_args()
559 chandransh 2390 
    args.cartId = cartId
2815 vikas 2391 
    args.sessionSource = sessionSource
2392 
    args.sessionStartTime = sessionStartTime
559 chandransh 2393 
    args.write(self._oprot)
2394 
    self._oprot.writeMessageEnd()
2395 
    self._oprot.trans.flush()
2396 
 
690 chandransh 2397 
  def recv_createOrders(self, ):
559 chandransh 2398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2399 
    if mtype == TMessageType.EXCEPTION:
2400 
      x = TApplicationException()
2401 
      x.read(self._iprot)
2402 
      self._iprot.readMessageEnd()
2403 
      raise x
690 chandransh 2404 
    result = createOrders_result()
559 chandransh 2405 
    result.read(self._iprot)
2406 
    self._iprot.readMessageEnd()
130 ashish 2407 
    if result.success != None:
2408 
      return result.success
559 chandransh 2409 
    if result.scx != None:
2410 
      raise result.scx
690 chandransh 2411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2412 
 
559 chandransh 2413 
  def validateCart(self, cartId):
130 ashish 2414 
    """
690 chandransh 2415 
    Validates that:
2416 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2417 
    2. All of the lines in the cart are active items.
690 chandransh 2418 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2419 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2420 
 
130 ashish 2421 
    Parameters:
559 chandransh 2422 
     - cartId
130 ashish 2423 
    """
559 chandransh 2424 
    self.send_validateCart(cartId)
2425 
    return self.recv_validateCart()
130 ashish 2426 
 
559 chandransh 2427 
  def send_validateCart(self, cartId):
2428 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2429 
    args = validateCart_args()
2430 
    args.cartId = cartId
130 ashish 2431 
    args.write(self._oprot)
2432 
    self._oprot.writeMessageEnd()
2433 
    self._oprot.trans.flush()
2434 
 
559 chandransh 2435 
  def recv_validateCart(self, ):
130 ashish 2436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2437 
    if mtype == TMessageType.EXCEPTION:
2438 
      x = TApplicationException()
2439 
      x.read(self._iprot)
2440 
      self._iprot.readMessageEnd()
2441 
      raise x
559 chandransh 2442 
    result = validateCart_result()
130 ashish 2443 
    result.read(self._iprot)
2444 
    self._iprot.readMessageEnd()
2445 
    if result.success != None:
2446 
      return result.success
575 chandransh 2447 
    if result.scex != None:
2448 
      raise result.scex
559 chandransh 2449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2450 
 
690 chandransh 2451 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2452 
    """
690 chandransh 2453 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2454 
 
575 chandransh 2455 
    Parameters:
690 chandransh 2456 
     - fromCartId
2457 
     - toCartId
2458 
    """
2459 
    self.send_mergeCart(fromCartId, toCartId)
2460 
    self.recv_mergeCart()
2461 
 
2462 
  def send_mergeCart(self, fromCartId, toCartId):
2463 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2464 
    args = mergeCart_args()
2465 
    args.fromCartId = fromCartId
2466 
    args.toCartId = toCartId
2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
2471 
  def recv_mergeCart(self, ):
2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
2478 
    result = mergeCart_result()
2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
2481 
    return
2482 
 
2483 
  def checkOut(self, cartId):
2484 
    """
2485 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2486 
 
2487 
    Parameters:
575 chandransh 2488 
     - cartId
2489 
    """
690 chandransh 2490 
    self.send_checkOut(cartId)
2491 
    return self.recv_checkOut()
575 chandransh 2492 
 
690 chandransh 2493 
  def send_checkOut(self, cartId):
2494 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2495 
    args = checkOut_args()
575 chandransh 2496 
    args.cartId = cartId
2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
690 chandransh 2501 
  def recv_checkOut(self, ):
575 chandransh 2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
690 chandransh 2508 
    result = checkOut_result()
575 chandransh 2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
2511 
    if result.success != None:
2512 
      return result.success
2513 
    if result.scex != None:
2514 
      raise result.scex
690 chandransh 2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2516 
 
690 chandransh 2517 
  def resetCart(self, cartId, items):
559 chandransh 2518 
    """
690 chandransh 2519 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2520 
    This methods removes the specified quantiry of the specified item from the cart.
2521 
 
559 chandransh 2522 
    Parameters:
690 chandransh 2523 
     - cartId
2524 
     - items
559 chandransh 2525 
    """
690 chandransh 2526 
    self.send_resetCart(cartId, items)
2527 
    return self.recv_resetCart()
130 ashish 2528 
 
690 chandransh 2529 
  def send_resetCart(self, cartId, items):
2530 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2531 
    args = resetCart_args()
2532 
    args.cartId = cartId
2533 
    args.items = items
559 chandransh 2534 
    args.write(self._oprot)
2535 
    self._oprot.writeMessageEnd()
2536 
    self._oprot.trans.flush()
2537 
 
690 chandransh 2538 
  def recv_resetCart(self, ):
559 chandransh 2539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2540 
    if mtype == TMessageType.EXCEPTION:
2541 
      x = TApplicationException()
2542 
      x.read(self._iprot)
2543 
      self._iprot.readMessageEnd()
2544 
      raise x
690 chandransh 2545 
    result = resetCart_result()
559 chandransh 2546 
    result.read(self._iprot)
2547 
    self._iprot.readMessageEnd()
690 chandransh 2548 
    if result.success != None:
2549 
      return result.success
2550 
    if result.scex != None:
2551 
      raise result.scex
2552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2553 
 
2981 rajveer 2554 
  def getUserCount(self, userType):
559 chandransh 2555 
    """
2981 rajveer 2556 
    Returns number of registered users.
2557 
    If userType = null, then it returns count of all users, including anonymous
2558 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2559 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 2560 
 
559 chandransh 2561 
    Parameters:
2981 rajveer 2562 
     - userType
559 chandransh 2563 
    """
2981 rajveer 2564 
    self.send_getUserCount(userType)
2565 
    return self.recv_getUserCount()
559 chandransh 2566 
 
2981 rajveer 2567 
  def send_getUserCount(self, userType):
2568 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2569 
    args = getUserCount_args()
2570 
    args.userType = userType
559 chandransh 2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2981 rajveer 2575 
  def recv_getUserCount(self, ):
559 chandransh 2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2981 rajveer 2582 
    result = getUserCount_result()
559 chandransh 2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
2585 
    if result.success != None:
2586 
      return result.success
2981 rajveer 2587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2588 
 
2981 rajveer 2589 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2590 
    """
2981 rajveer 2591 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2592 
    If any of startDate or endDate is -1, then that filter is ignored.
2593 
    If userType is null, then returns all the users, irrespective of anonymous flag
2594 
 
2595 
 
559 chandransh 2596 
    Parameters:
2981 rajveer 2597 
     - userType
2598 
     - startDate
2599 
     - endDate
559 chandransh 2600 
    """
2981 rajveer 2601 
    self.send_getAllUsers(userType, startDate, endDate)
2602 
    return self.recv_getAllUsers()
559 chandransh 2603 
 
2981 rajveer 2604 
  def send_getAllUsers(self, userType, startDate, endDate):
2605 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2606 
    args = getAllUsers_args()
2607 
    args.userType = userType
2608 
    args.startDate = startDate
2609 
    args.endDate = endDate
559 chandransh 2610 
    args.write(self._oprot)
2611 
    self._oprot.writeMessageEnd()
2612 
    self._oprot.trans.flush()
2613 
 
2981 rajveer 2614 
  def recv_getAllUsers(self, ):
559 chandransh 2615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2616 
    if mtype == TMessageType.EXCEPTION:
2617 
      x = TApplicationException()
2618 
      x.read(self._iprot)
2619 
      self._iprot.readMessageEnd()
2620 
      raise x
2981 rajveer 2621 
    result = getAllUsers_result()
559 chandransh 2622 
    result.read(self._iprot)
2623 
    self._iprot.readMessageEnd()
2624 
    if result.success != None:
2625 
      return result.success
2981 rajveer 2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2627 
 
2981 rajveer 2628 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 2629 
    """
2630 
    Parameters:
2981 rajveer 2631 
     - user_id
2632 
     - entity_id
2633 
     - slide
2634 
     - note
559 chandransh 2635 
    """
2981 rajveer 2636 
    self.send_putUserNote(user_id, entity_id, slide, note)
2637 
    self.recv_putUserNote()
559 chandransh 2638 
 
2981 rajveer 2639 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2640 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2641 
    args = putUserNote_args()
2642 
    args.user_id = user_id
2643 
    args.entity_id = entity_id
2644 
    args.slide = slide
2645 
    args.note = note
559 chandransh 2646 
    args.write(self._oprot)
2647 
    self._oprot.writeMessageEnd()
2648 
    self._oprot.trans.flush()
2649 
 
2981 rajveer 2650 
  def recv_putUserNote(self, ):
559 chandransh 2651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2652 
    if mtype == TMessageType.EXCEPTION:
2653 
      x = TApplicationException()
2654 
      x.read(self._iprot)
2655 
      self._iprot.readMessageEnd()
2656 
      raise x
2981 rajveer 2657 
    result = putUserNote_result()
559 chandransh 2658 
    result.read(self._iprot)
2659 
    self._iprot.readMessageEnd()
2660 
    return
2661 
 
2981 rajveer 2662 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 2663 
    """
2664 
    Parameters:
2981 rajveer 2665 
     - user_id
2666 
     - entity_id
559 chandransh 2667 
    """
2981 rajveer 2668 
    self.send_getUserNotes(user_id, entity_id)
2669 
    return self.recv_getUserNotes()
559 chandransh 2670 
 
2981 rajveer 2671 
  def send_getUserNotes(self, user_id, entity_id):
2672 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2673 
    args = getUserNotes_args()
2674 
    args.user_id = user_id
2675 
    args.entity_id = entity_id
559 chandransh 2676 
    args.write(self._oprot)
2677 
    self._oprot.writeMessageEnd()
2678 
    self._oprot.trans.flush()
2679 
 
2981 rajveer 2680 
  def recv_getUserNotes(self, ):
559 chandransh 2681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2682 
    if mtype == TMessageType.EXCEPTION:
2683 
      x = TApplicationException()
2684 
      x.read(self._iprot)
2685 
      self._iprot.readMessageEnd()
2686 
      raise x
2981 rajveer 2687 
    result = getUserNotes_result()
559 chandransh 2688 
    result.read(self._iprot)
2689 
    self._iprot.readMessageEnd()
2981 rajveer 2690 
    if result.success != None:
2691 
      return result.success
2692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
559 chandransh 2693 
 
2981 rajveer 2694 
  def getMyResearchItems(self, userId):
559 chandransh 2695 
    """
2981 rajveer 2696 
    Returns list of item ids in myresearch for the user
2697 
 
559 chandransh 2698 
    Parameters:
772 rajveer 2699 
     - userId
559 chandransh 2700 
    """
2981 rajveer 2701 
    self.send_getMyResearchItems(userId)
2702 
    return self.recv_getMyResearchItems()
559 chandransh 2703 
 
2981 rajveer 2704 
  def send_getMyResearchItems(self, userId):
2705 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2706 
    args = getMyResearchItems_args()
772 rajveer 2707 
    args.userId = userId
559 chandransh 2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2981 rajveer 2712 
  def recv_getMyResearchItems(self, ):
559 chandransh 2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2981 rajveer 2719 
    result = getMyResearchItems_result()
559 chandransh 2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    if result.success != None:
2723 
      return result.success
2724 
    if result.scx != None:
2725 
      raise result.scx
2981 rajveer 2726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2727 
 
2981 rajveer 2728 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2729 
    """
2981 rajveer 2730 
    add item to my research for a user
2731 
 
559 chandransh 2732 
    Parameters:
2981 rajveer 2733 
     - userId
2734 
     - itemId
559 chandransh 2735 
    """
2981 rajveer 2736 
    self.send_updateMyResearch(userId, itemId)
2737 
    return self.recv_updateMyResearch()
559 chandransh 2738 
 
2981 rajveer 2739 
  def send_updateMyResearch(self, userId, itemId):
2740 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2741 
    args = updateMyResearch_args()
2742 
    args.userId = userId
2743 
    args.itemId = itemId
559 chandransh 2744 
    args.write(self._oprot)
2745 
    self._oprot.writeMessageEnd()
2746 
    self._oprot.trans.flush()
2747 
 
2981 rajveer 2748 
  def recv_updateMyResearch(self, ):
559 chandransh 2749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2750 
    if mtype == TMessageType.EXCEPTION:
2751 
      x = TApplicationException()
2752 
      x.read(self._iprot)
2753 
      self._iprot.readMessageEnd()
2754 
      raise x
2981 rajveer 2755 
    result = updateMyResearch_result()
559 chandransh 2756 
    result.read(self._iprot)
2757 
    self._iprot.readMessageEnd()
2981 rajveer 2758 
    if result.success != None:
2759 
      return result.success
2760 
    if result.scx != None:
2761 
      raise result.scx
2762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2763 
 
2981 rajveer 2764 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2765 
    """
2981 rajveer 2766 
    delete item from my research for a user
1596 ankur.sing 2767 
 
2768 
    Parameters:
2981 rajveer 2769 
     - userId
2770 
     - itemId
1596 ankur.sing 2771 
    """
2981 rajveer 2772 
    self.send_deleteItemFromMyResearch(userId, itemId)
2773 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2774 
 
2981 rajveer 2775 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2776 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2777 
    args = deleteItemFromMyResearch_args()
2778 
    args.userId = userId
2779 
    args.itemId = itemId
1596 ankur.sing 2780 
    args.write(self._oprot)
2781 
    self._oprot.writeMessageEnd()
2782 
    self._oprot.trans.flush()
2783 
 
2981 rajveer 2784 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2786 
    if mtype == TMessageType.EXCEPTION:
2787 
      x = TApplicationException()
2788 
      x.read(self._iprot)
2789 
      self._iprot.readMessageEnd()
2790 
      raise x
2981 rajveer 2791 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2792 
    result.read(self._iprot)
2793 
    self._iprot.readMessageEnd()
2981 rajveer 2794 
    if result.scx != None:
2795 
      raise result.scx
2796 
    return
1596 ankur.sing 2797 
 
2981 rajveer 2798 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2799 
    """
2981 rajveer 2800 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 2801 
 
2802 
    Parameters:
2981 rajveer 2803 
     - userId
1673 ankur.sing 2804 
    """
2981 rajveer 2805 
    self.send_getBrowseHistoryItems(userId)
2806 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2807 
 
2981 rajveer 2808 
  def send_getBrowseHistoryItems(self, userId):
2809 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2810 
    args = getBrowseHistoryItems_args()
2811 
    args.userId = userId
1673 ankur.sing 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
2981 rajveer 2816 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
2981 rajveer 2823 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
2826 
    if result.success != None:
2827 
      return result.success
2981 rajveer 2828 
    if result.scx != None:
2829 
      raise result.scx
2830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2831 
 
2981 rajveer 2832 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2833 
    """
2981 rajveer 2834 
    add item to browse history for a user
2642 varun.gupt 2835 
 
2836 
    Parameters:
2981 rajveer 2837 
     - userId
2838 
     - itemId
2642 varun.gupt 2839 
    """
2981 rajveer 2840 
    self.send_updateBrowseHistory(userId, itemId)
2841 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2842 
 
2981 rajveer 2843 
  def send_updateBrowseHistory(self, userId, itemId):
2844 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2845 
    args = updateBrowseHistory_args()
2846 
    args.userId = userId
2847 
    args.itemId = itemId
2642 varun.gupt 2848 
    args.write(self._oprot)
2849 
    self._oprot.writeMessageEnd()
2850 
    self._oprot.trans.flush()
2851 
 
2981 rajveer 2852 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2854 
    if mtype == TMessageType.EXCEPTION:
2855 
      x = TApplicationException()
2856 
      x.read(self._iprot)
2857 
      self._iprot.readMessageEnd()
2858 
      raise x
2981 rajveer 2859 
    result = updateBrowseHistory_result()
2642 varun.gupt 2860 
    result.read(self._iprot)
2861 
    self._iprot.readMessageEnd()
2862 
    return
2863 
 
2864 
 
94 ashish 2865 
class Processor(Iface, TProcessor):
2866 
  def __init__(self, handler):
2867 
    self._handler = handler
2868 
    self._processMap = {}
765 rajveer 2869 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2870 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2871 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2872 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 2873 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 2874 
    self._processMap["createUser"] = Processor.process_createUser
2875 
    self._processMap["updateUser"] = Processor.process_updateUser
2876 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2877 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2878 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2879 
    self._processMap["userExists"] = Processor.process_userExists
2880 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2881 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2882 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2883 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2884 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2885 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2886 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2887 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2888 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2889 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2890 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2891 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2892 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2893 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2894 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2895 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2896 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2897 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2898 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2899 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2900 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2901 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2902 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2903 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2904 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2905 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2906 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2907 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2908 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2909 
    self._processMap["createCart"] = Processor.process_createCart
2910 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2911 
    self._processMap["getCart"] = Processor.process_getCart
2912 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2913 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2914 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2915 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2916 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2917 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2918 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2919 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2920 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2921 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2922 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2923 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2924 
    self._processMap["validateCart"] = Processor.process_validateCart
2925 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2926 
    self._processMap["checkOut"] = Processor.process_checkOut
2927 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 2928 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2929 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2930 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2931 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
2981 rajveer 2932 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
2933 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2934 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2935 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
2936 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
94 ashish 2937 
 
2938 
  def process(self, iprot, oprot):
2939 
    (name, type, seqid) = iprot.readMessageBegin()
2940 
    if name not in self._processMap:
2941 
      iprot.skip(TType.STRUCT)
2942 
      iprot.readMessageEnd()
2943 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2944 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2945 
      x.write(oprot)
2946 
      oprot.writeMessageEnd()
2947 
      oprot.trans.flush()
2948 
      return
2949 
    else:
2950 
      self._processMap[name](self, seqid, iprot, oprot)
2951 
    return True
2952 
 
765 rajveer 2953 
  def process_closeSession(self, seqid, iprot, oprot):
2954 
    args = closeSession_args()
2955 
    args.read(iprot)
2956 
    iprot.readMessageEnd()
2957 
    result = closeSession_result()
2958 
    self._handler.closeSession()
2959 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2960 
    result.write(oprot)
2961 
    oprot.writeMessageEnd()
2962 
    oprot.trans.flush()
2963 
 
559 chandransh 2964 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2965 
    args = createAnonymousUser_args()
94 ashish 2966 
    args.read(iprot)
2967 
    iprot.readMessageEnd()
559 chandransh 2968 
    result = createAnonymousUser_result()
94 ashish 2969 
    try:
559 chandransh 2970 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2971 
    except UserContextException, ucex:
2972 
      result.ucex = ucex
2973 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2974 
    result.write(oprot)
2975 
    oprot.writeMessageEnd()
2976 
    oprot.trans.flush()
2977 
 
559 chandransh 2978 
  def process_getUserById(self, seqid, iprot, oprot):
2979 
    args = getUserById_args()
94 ashish 2980 
    args.read(iprot)
2981 
    iprot.readMessageEnd()
559 chandransh 2982 
    result = getUserById_result()
94 ashish 2983 
    try:
559 chandransh 2984 
      result.success = self._handler.getUserById(args.userId)
2985 
    except UserContextException, ucex:
2986 
      result.ucex = ucex
2987 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2988 
    result.write(oprot)
2989 
    oprot.writeMessageEnd()
2990 
    oprot.trans.flush()
2991 
 
1491 vikas 2992 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2993 
    args = getUserByEmail_args()
2994 
    args.read(iprot)
2995 
    iprot.readMessageEnd()
2996 
    result = getUserByEmail_result()
2997 
    try:
2998 
      result.success = self._handler.getUserByEmail(args.email)
2999 
    except UserContextException, ucex:
3000 
      result.ucex = ucex
3001 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3002 
    result.write(oprot)
3003 
    oprot.writeMessageEnd()
3004 
    oprot.trans.flush()
3005 
 
3032 mandeep.dh 3006 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3007 
    args = getUserByMobileNumber_args()
3008 
    args.read(iprot)
3009 
    iprot.readMessageEnd()
3010 
    result = getUserByMobileNumber_result()
3011 
    try:
3012 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3013 
    except UserContextException, ucex:
3014 
      result.ucex = ucex
3015 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3016 
    result.write(oprot)
3017 
    oprot.writeMessageEnd()
3018 
    oprot.trans.flush()
3019 
 
559 chandransh 3020 
  def process_createUser(self, seqid, iprot, oprot):
3021 
    args = createUser_args()
94 ashish 3022 
    args.read(iprot)
3023 
    iprot.readMessageEnd()
559 chandransh 3024 
    result = createUser_result()
94 ashish 3025 
    try:
559 chandransh 3026 
      result.success = self._handler.createUser(args.user)
3027 
    except UserContextException, ucex:
3028 
      result.ucex = ucex
3029 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3030 
    result.write(oprot)
3031 
    oprot.writeMessageEnd()
3032 
    oprot.trans.flush()
3033 
 
559 chandransh 3034 
  def process_updateUser(self, seqid, iprot, oprot):
3035 
    args = updateUser_args()
94 ashish 3036 
    args.read(iprot)
3037 
    iprot.readMessageEnd()
559 chandransh 3038 
    result = updateUser_result()
94 ashish 3039 
    try:
559 chandransh 3040 
      result.success = self._handler.updateUser(args.user)
3041 
    except UserContextException, ucex:
3042 
      result.ucex = ucex
3043 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3044 
    result.write(oprot)
3045 
    oprot.writeMessageEnd()
3046 
    oprot.trans.flush()
3047 
 
559 chandransh 3048 
  def process_deleteUser(self, seqid, iprot, oprot):
3049 
    args = deleteUser_args()
94 ashish 3050 
    args.read(iprot)
3051 
    iprot.readMessageEnd()
559 chandransh 3052 
    result = deleteUser_result()
94 ashish 3053 
    try:
559 chandransh 3054 
      result.success = self._handler.deleteUser(args.userId)
3055 
    except UserContextException, ucex:
3056 
      result.ucex = ucex
3057 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3058 
    result.write(oprot)
3059 
    oprot.writeMessageEnd()
3060 
    oprot.trans.flush()
3061 
 
559 chandransh 3062 
  def process_getUserState(self, seqid, iprot, oprot):
3063 
    args = getUserState_args()
94 ashish 3064 
    args.read(iprot)
3065 
    iprot.readMessageEnd()
559 chandransh 3066 
    result = getUserState_result()
94 ashish 3067 
    try:
559 chandransh 3068 
      result.success = self._handler.getUserState(args.userId)
3069 
    except UserContextException, ucex:
3070 
      result.ucex = ucex
3071 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3072 
    result.write(oprot)
3073 
    oprot.writeMessageEnd()
3074 
    oprot.trans.flush()
3075 
 
122 ashish 3076 
  def process_authenticateUser(self, seqid, iprot, oprot):
3077 
    args = authenticateUser_args()
3078 
    args.read(iprot)
3079 
    iprot.readMessageEnd()
3080 
    result = authenticateUser_result()
3081 
    try:
559 chandransh 3082 
      result.success = self._handler.authenticateUser(args.email, args.password)
3083 
    except AuthenticationException, auex:
3084 
      result.auex = auex
122 ashish 3085 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3086 
    result.write(oprot)
3087 
    oprot.writeMessageEnd()
3088 
    oprot.trans.flush()
3089 
 
94 ashish 3090 
  def process_userExists(self, seqid, iprot, oprot):
3091 
    args = userExists_args()
3092 
    args.read(iprot)
3093 
    iprot.readMessageEnd()
3094 
    result = userExists_result()
3095 
    try:
3096 
      result.success = self._handler.userExists(args.email)
3097 
    except UserContextException, ucx:
3098 
      result.ucx = ucx
3099 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3100 
    result.write(oprot)
3101 
    oprot.writeMessageEnd()
3102 
    oprot.trans.flush()
3103 
 
3104 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3105 
    args = addAddressForUser_args()
3106 
    args.read(iprot)
3107 
    iprot.readMessageEnd()
3108 
    result = addAddressForUser_result()
3109 
    try:
567 rajveer 3110 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3111 
    except UserContextException, ucx:
3112 
      result.ucx = ucx
3113 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3114 
    result.write(oprot)
3115 
    oprot.writeMessageEnd()
3116 
    oprot.trans.flush()
3117 
 
3118 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3119 
    args = removeAddressForUser_args()
3120 
    args.read(iprot)
3121 
    iprot.readMessageEnd()
3122 
    result = removeAddressForUser_result()
3123 
    try:
3124 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3125 
    except UserContextException, ucx:
3126 
      result.ucx = ucx
3127 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3128 
    result.write(oprot)
3129 
    oprot.writeMessageEnd()
3130 
    oprot.trans.flush()
3131 
 
3132 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3133 
    args = setUserAsLoggedIn_args()
3134 
    args.read(iprot)
3135 
    iprot.readMessageEnd()
3136 
    result = setUserAsLoggedIn_result()
3137 
    try:
3138 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3139 
    except UserContextException, ucx:
3140 
      result.ucx = ucx
3141 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3142 
    result.write(oprot)
3143 
    oprot.writeMessageEnd()
3144 
    oprot.trans.flush()
3145 
 
3146 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3147 
    args = setUserAsLoggedOut_args()
3148 
    args.read(iprot)
3149 
    iprot.readMessageEnd()
3150 
    result = setUserAsLoggedOut_result()
3151 
    try:
3152 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3153 
    except UserContextException, ucx:
3154 
      result.ucx = ucx
3155 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3156 
    result.write(oprot)
3157 
    oprot.writeMessageEnd()
3158 
    oprot.trans.flush()
3159 
 
504 rajveer 3160 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3161 
    args = setDefaultAddress_args()
3162 
    args.read(iprot)
3163 
    iprot.readMessageEnd()
3164 
    result = setDefaultAddress_result()
3165 
    try:
3166 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3167 
    except UserContextException, ucx:
3168 
      result.ucx = ucx
3169 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3170 
    result.write(oprot)
3171 
    oprot.writeMessageEnd()
3172 
    oprot.trans.flush()
3173 
 
94 ashish 3174 
  def process_updatePassword(self, seqid, iprot, oprot):
3175 
    args = updatePassword_args()
3176 
    args.read(iprot)
3177 
    iprot.readMessageEnd()
3178 
    result = updatePassword_result()
3179 
    try:
594 rajveer 3180 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3181 
    except UserContextException, ucx:
3182 
      result.ucx = ucx
3183 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3184 
    result.write(oprot)
3185 
    oprot.writeMessageEnd()
3186 
    oprot.trans.flush()
3187 
 
581 rajveer 3188 
  def process_forgotPassword(self, seqid, iprot, oprot):
3189 
    args = forgotPassword_args()
3190 
    args.read(iprot)
3191 
    iprot.readMessageEnd()
3192 
    result = forgotPassword_result()
3193 
    try:
884 rajveer 3194 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3195 
    except UserContextException, ucx:
3196 
      result.ucx = ucx
3197 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3198 
    result.write(oprot)
3199 
    oprot.writeMessageEnd()
3200 
    oprot.trans.flush()
3201 
 
594 rajveer 3202 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3203 
    args = getAllAddressesForUser_args()
3204 
    args.read(iprot)
3205 
    iprot.readMessageEnd()
3206 
    result = getAllAddressesForUser_result()
3207 
    try:
3208 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3209 
    except UserContextException, ucx:
3210 
      result.ucx = ucx
3211 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3212 
    result.write(oprot)
3213 
    oprot.writeMessageEnd()
3214 
    oprot.trans.flush()
3215 
 
1894 vikas 3216 
  def process_getAddressById(self, seqid, iprot, oprot):
3217 
    args = getAddressById_args()
3218 
    args.read(iprot)
3219 
    iprot.readMessageEnd()
3220 
    result = getAddressById_result()
3221 
    try:
3222 
      result.success = self._handler.getAddressById(args.addressId)
3223 
    except UserContextException, ucx:
3224 
      result.ucx = ucx
3225 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3226 
    result.write(oprot)
3227 
    oprot.writeMessageEnd()
3228 
    oprot.trans.flush()
3229 
 
594 rajveer 3230 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3231 
    args = getDefaultAddressId_args()
3232 
    args.read(iprot)
3233 
    iprot.readMessageEnd()
3234 
    result = getDefaultAddressId_result()
3235 
    try:
3236 
      result.success = self._handler.getDefaultAddressId(args.userId)
3237 
    except UserContextException, ucx:
3238 
      result.ucx = ucx
3239 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3240 
    result.write(oprot)
3241 
    oprot.writeMessageEnd()
3242 
    oprot.trans.flush()
3243 
 
785 rajveer 3244 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3245 
    args = getDefaultPincode_args()
3246 
    args.read(iprot)
3247 
    iprot.readMessageEnd()
3248 
    result = getDefaultPincode_result()
3249 
    try:
3250 
      result.success = self._handler.getDefaultPincode(args.userId)
3251 
    except UserContextException, ucx:
3252 
      result.ucx = ucx
3253 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3254 
    result.write(oprot)
3255 
    oprot.writeMessageEnd()
3256 
    oprot.trans.flush()
3257 
 
1274 varun.gupt 3258 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3259 
    args = saveUserCommunication_args()
3260 
    args.read(iprot)
3261 
    iprot.readMessageEnd()
3262 
    result = saveUserCommunication_result()
3263 
    try:
3264 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3265 
    except UserCommunicationException, ucx:
3266 
      result.ucx = ucx
3267 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3268 
    result.write(oprot)
3269 
    oprot.writeMessageEnd()
3270 
    oprot.trans.flush()
3271 
 
1590 varun.gupt 3272 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3273 
    args = getUserCommunicationById_args()
3274 
    args.read(iprot)
3275 
    iprot.readMessageEnd()
3276 
    result = getUserCommunicationById_result()
3277 
    try:
3278 
      result.success = self._handler.getUserCommunicationById(args.id)
3279 
    except UserCommunicationException, ucx:
3280 
      result.ucx = ucx
3281 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3282 
    result.write(oprot)
3283 
    oprot.writeMessageEnd()
3284 
    oprot.trans.flush()
3285 
 
3286 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3287 
    args = getUserCommunicationByUser_args()
3288 
    args.read(iprot)
3289 
    iprot.readMessageEnd()
3290 
    result = getUserCommunicationByUser_result()
3291 
    try:
3292 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3293 
    except UserCommunicationException, ucx:
3294 
      result.ucx = ucx
3295 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3296 
    result.write(oprot)
3297 
    oprot.writeMessageEnd()
3298 
    oprot.trans.flush()
3299 
 
3300 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3301 
    args = getAllUserCommunications_args()
3302 
    args.read(iprot)
3303 
    iprot.readMessageEnd()
3304 
    result = getAllUserCommunications_result()
3305 
    try:
3306 
      result.success = self._handler.getAllUserCommunications()
3307 
    except UserCommunicationException, ucx:
3308 
      result.ucx = ucx
3309 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3310 
    result.write(oprot)
3311 
    oprot.writeMessageEnd()
3312 
    oprot.trans.flush()
3313 
 
1845 vikas 3314 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3315 
    args = createMasterAffiliate_args()
3316 
    args.read(iprot)
3317 
    iprot.readMessageEnd()
3318 
    result = createMasterAffiliate_result()
3319 
    try:
1859 vikas 3320 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3321 
    except UserAffiliateException, utx:
1845 vikas 3322 
      result.utx = utx
3323 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3324 
    result.write(oprot)
3325 
    oprot.writeMessageEnd()
3326 
    oprot.trans.flush()
3327 
 
1899 vikas 3328 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3329 
    args = getAllMasterAffiliates_args()
3330 
    args.read(iprot)
3331 
    iprot.readMessageEnd()
3332 
    result = getAllMasterAffiliates_result()
3333 
    try:
3334 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3335 
    except UserAffiliateException, utx:
1899 vikas 3336 
      result.utx = utx
3337 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3338 
    result.write(oprot)
3339 
    oprot.writeMessageEnd()
3340 
    oprot.trans.flush()
3341 
 
1845 vikas 3342 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3343 
    args = getMasterAffiliateById_args()
3344 
    args.read(iprot)
3345 
    iprot.readMessageEnd()
3346 
    result = getMasterAffiliateById_result()
3347 
    try:
3348 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3349 
    except UserAffiliateException, utx:
1845 vikas 3350 
      result.utx = utx
3351 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3352 
    result.write(oprot)
3353 
    oprot.writeMessageEnd()
3354 
    oprot.trans.flush()
3355 
 
3356 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3357 
    args = getMasterAffiliateByName_args()
3358 
    args.read(iprot)
3359 
    iprot.readMessageEnd()
3360 
    result = getMasterAffiliateByName_result()
3361 
    try:
3362 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3363 
    except UserAffiliateException, utx:
1845 vikas 3364 
      result.utx = utx
3365 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3366 
    result.write(oprot)
3367 
    oprot.writeMessageEnd()
3368 
    oprot.trans.flush()
3369 
 
3370 
  def process_createAffiliate(self, seqid, iprot, oprot):
3371 
    args = createAffiliate_args()
3372 
    args.read(iprot)
3373 
    iprot.readMessageEnd()
3374 
    result = createAffiliate_result()
3375 
    try:
1859 vikas 3376 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3377 
    except UserAffiliateException, utx:
1845 vikas 3378 
      result.utx = utx
3379 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3380 
    result.write(oprot)
3381 
    oprot.writeMessageEnd()
3382 
    oprot.trans.flush()
3383 
 
3384 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3385 
    args = getAffiliateById_args()
3386 
    args.read(iprot)
3387 
    iprot.readMessageEnd()
3388 
    result = getAffiliateById_result()
3389 
    try:
3390 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3391 
    except UserAffiliateException, utx:
1845 vikas 3392 
      result.utx = utx
3393 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3394 
    result.write(oprot)
3395 
    oprot.writeMessageEnd()
3396 
    oprot.trans.flush()
3397 
 
3398 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3399 
    args = getAffiliateByName_args()
3400 
    args.read(iprot)
3401 
    iprot.readMessageEnd()
3402 
    result = getAffiliateByName_result()
3403 
    try:
3404 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3405 
    except UserAffiliateException, utx:
1845 vikas 3406 
      result.utx = utx
3407 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3408 
    result.write(oprot)
3409 
    oprot.writeMessageEnd()
3410 
    oprot.trans.flush()
3411 
 
3412 
  def process_getTrackerById(self, seqid, iprot, oprot):
3413 
    args = getTrackerById_args()
3414 
    args.read(iprot)
3415 
    iprot.readMessageEnd()
3416 
    result = getTrackerById_result()
3417 
    try:
1996 vikas 3418 
      result.success = self._handler.getTrackerById(args.id)
3419 
    except UserAffiliateException, utx:
1845 vikas 3420 
      result.utx = utx
3421 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3422 
    result.write(oprot)
3423 
    oprot.writeMessageEnd()
3424 
    oprot.trans.flush()
3425 
 
1996 vikas 3426 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3427 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3428 
    args.read(iprot)
3429 
    iprot.readMessageEnd()
1996 vikas 3430 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3431 
    try:
1996 vikas 3432 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3433 
    except UserAffiliateException, utx:
1845 vikas 3434 
      result.utx = utx
1996 vikas 3435 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3436 
    result.write(oprot)
3437 
    oprot.writeMessageEnd()
3438 
    oprot.trans.flush()
3439 
 
3440 
  def process_addTrackLog(self, seqid, iprot, oprot):
3441 
    args = addTrackLog_args()
3442 
    args.read(iprot)
3443 
    iprot.readMessageEnd()
3444 
    result = addTrackLog_result()
3445 
    try:
1996 vikas 3446 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3447 
    except UserAffiliateException, utx:
1845 vikas 3448 
      result.utx = utx
3449 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3450 
    result.write(oprot)
3451 
    oprot.writeMessageEnd()
3452 
    oprot.trans.flush()
3453 
 
3454 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3455 
    args = getTrackLogById_args()
3456 
    args.read(iprot)
3457 
    iprot.readMessageEnd()
3458 
    result = getTrackLogById_result()
3459 
    try:
3460 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3461 
    except UserAffiliateException, utx:
1845 vikas 3462 
      result.utx = utx
3463 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3464 
    result.write(oprot)
3465 
    oprot.writeMessageEnd()
3466 
    oprot.trans.flush()
3467 
 
1996 vikas 3468 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3469 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3470 
    args.read(iprot)
3471 
    iprot.readMessageEnd()
1996 vikas 3472 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3473 
    try:
1996 vikas 3474 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3475 
    except UserAffiliateException, utx:
1845 vikas 3476 
      result.utx = utx
1996 vikas 3477 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3478 
    result.write(oprot)
3479 
    oprot.writeMessageEnd()
3480 
    oprot.trans.flush()
3481 
 
3482 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3483 
    args = getTrackLogsByUser_args()
3484 
    args.read(iprot)
3485 
    iprot.readMessageEnd()
3486 
    result = getTrackLogsByUser_result()
3487 
    try:
3488 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3489 
    except UserAffiliateException, utx:
1845 vikas 3490 
      result.utx = utx
3491 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3492 
    result.write(oprot)
3493 
    oprot.writeMessageEnd()
3494 
    oprot.trans.flush()
3495 
 
3496 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3497 
    args = getTrackLogs_args()
3498 
    args.read(iprot)
3499 
    iprot.readMessageEnd()
3500 
    result = getTrackLogs_result()
3501 
    try:
1996 vikas 3502 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3503 
    except UserAffiliateException, utx:
1845 vikas 3504 
      result.utx = utx
3505 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3506 
    result.write(oprot)
3507 
    oprot.writeMessageEnd()
3508 
    oprot.trans.flush()
3509 
 
559 chandransh 3510 
  def process_createCart(self, seqid, iprot, oprot):
3511 
    args = createCart_args()
94 ashish 3512 
    args.read(iprot)
3513 
    iprot.readMessageEnd()
559 chandransh 3514 
    result = createCart_result()
94 ashish 3515 
    try:
559 chandransh 3516 
      result.success = self._handler.createCart(args.userId)
3517 
    except ShoppingCartException, scx:
3518 
      result.scx = scx
3519 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3520 
    result.write(oprot)
3521 
    oprot.writeMessageEnd()
3522 
    oprot.trans.flush()
3523 
 
559 chandransh 3524 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3525 
    args = getCurrentCart_args()
94 ashish 3526 
    args.read(iprot)
3527 
    iprot.readMessageEnd()
559 chandransh 3528 
    result = getCurrentCart_result()
94 ashish 3529 
    try:
559 chandransh 3530 
      result.success = self._handler.getCurrentCart(args.userId)
3531 
    except ShoppingCartException, scx:
3532 
      result.scx = scx
3533 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3534 
    result.write(oprot)
3535 
    oprot.writeMessageEnd()
3536 
    oprot.trans.flush()
3537 
 
559 chandransh 3538 
  def process_getCart(self, seqid, iprot, oprot):
3539 
    args = getCart_args()
94 ashish 3540 
    args.read(iprot)
3541 
    iprot.readMessageEnd()
559 chandransh 3542 
    result = getCart_result()
94 ashish 3543 
    try:
559 chandransh 3544 
      result.success = self._handler.getCart(args.cartId)
3545 
    except ShoppingCartException, scx:
3546 
      result.scx = scx
3547 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3548 
    result.write(oprot)
3549 
    oprot.writeMessageEnd()
3550 
    oprot.trans.flush()
3551 
 
559 chandransh 3552 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3553 
    args = getCartsForUser_args()
94 ashish 3554 
    args.read(iprot)
3555 
    iprot.readMessageEnd()
559 chandransh 3556 
    result = getCartsForUser_result()
94 ashish 3557 
    try:
559 chandransh 3558 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3559 
    except ShoppingCartException, scx:
3560 
      result.scx = scx
3561 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3562 
    result.write(oprot)
3563 
    oprot.writeMessageEnd()
3564 
    oprot.trans.flush()
3565 
 
559 chandransh 3566 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3567 
    args = getCartsByStatus_args()
94 ashish 3568 
    args.read(iprot)
3569 
    iprot.readMessageEnd()
559 chandransh 3570 
    result = getCartsByStatus_result()
94 ashish 3571 
    try:
559 chandransh 3572 
      result.success = self._handler.getCartsByStatus(args.status)
3573 
    except ShoppingCartException, scx:
3574 
      result.scx = scx
3575 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3576 
    result.write(oprot)
3577 
    oprot.writeMessageEnd()
3578 
    oprot.trans.flush()
3579 
 
559 chandransh 3580 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3581 
    args = getCartsByTime_args()
94 ashish 3582 
    args.read(iprot)
3583 
    iprot.readMessageEnd()
559 chandransh 3584 
    result = getCartsByTime_result()
94 ashish 3585 
    try:
559 chandransh 3586 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3587 
    except ShoppingCartException, scx:
3588 
      result.scx = scx
3589 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3590 
    result.write(oprot)
3591 
    oprot.writeMessageEnd()
3592 
    oprot.trans.flush()
3593 
 
559 chandransh 3594 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3595 
    args = changeCartStatus_args()
130 ashish 3596 
    args.read(iprot)
3597 
    iprot.readMessageEnd()
559 chandransh 3598 
    result = changeCartStatus_result()
130 ashish 3599 
    try:
559 chandransh 3600 
      self._handler.changeCartStatus(args.cartId, args.status)
3601 
    except ShoppingCartException, scx:
3602 
      result.scx = scx
3603 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3604 
    result.write(oprot)
3605 
    oprot.writeMessageEnd()
3606 
    oprot.trans.flush()
94 ashish 3607 
 
559 chandransh 3608 
  def process_addItemToCart(self, seqid, iprot, oprot):
3609 
    args = addItemToCart_args()
130 ashish 3610 
    args.read(iprot)
3611 
    iprot.readMessageEnd()
559 chandransh 3612 
    result = addItemToCart_result()
130 ashish 3613 
    try:
2035 rajveer 3614 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3615 
    except ShoppingCartException, scx:
3616 
      result.scx = scx
3617 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3618 
    result.write(oprot)
3619 
    oprot.writeMessageEnd()
3620 
    oprot.trans.flush()
3621 
 
559 chandransh 3622 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3623 
    args = deleteItemFromCart_args()
3624 
    args.read(iprot)
3625 
    iprot.readMessageEnd()
3626 
    result = deleteItemFromCart_result()
3627 
    try:
3628 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3629 
    except ShoppingCartException, scx:
3630 
      result.scx = scx
3631 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3632 
    result.write(oprot)
3633 
    oprot.writeMessageEnd()
3634 
    oprot.trans.flush()
130 ashish 3635 
 
559 chandransh 3636 
  def process_changeQuantity(self, seqid, iprot, oprot):
3637 
    args = changeQuantity_args()
3638 
    args.read(iprot)
3639 
    iprot.readMessageEnd()
3640 
    result = changeQuantity_result()
3641 
    try:
3642 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3643 
    except ShoppingCartException, scx:
3644 
      result.scx = scx
3645 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3646 
    result.write(oprot)
3647 
    oprot.writeMessageEnd()
3648 
    oprot.trans.flush()
3649 
 
3650 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3651 
    args = changeItemStatus_args()
3652 
    args.read(iprot)
3653 
    iprot.readMessageEnd()
3654 
    result = changeItemStatus_result()
3655 
    try:
3656 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3657 
    except ShoppingCartException, scx:
3658 
      result.scx = scx
3659 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3660 
    result.write(oprot)
3661 
    oprot.writeMessageEnd()
3662 
    oprot.trans.flush()
3663 
 
3664 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3665 
    args = addAddressToCart_args()
3666 
    args.read(iprot)
3667 
    iprot.readMessageEnd()
3668 
    result = addAddressToCart_result()
575 chandransh 3669 
    try:
3670 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3671 
    except ShoppingCartException, scx:
3672 
      result.scx = scx
559 chandransh 3673 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3674 
    result.write(oprot)
3675 
    oprot.writeMessageEnd()
3676 
    oprot.trans.flush()
3677 
 
1976 varun.gupt 3678 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3679 
    args = applyCouponToCart_args()
3680 
    args.read(iprot)
3681 
    iprot.readMessageEnd()
3682 
    result = applyCouponToCart_result()
3683 
    try:
3684 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3685 
    except ShoppingCartException, scx:
3686 
      result.scx = scx
3687 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3688 
    result.write(oprot)
3689 
    oprot.writeMessageEnd()
3690 
    oprot.trans.flush()
3691 
 
3692 
  def process_removeCoupon(self, seqid, iprot, oprot):
3693 
    args = removeCoupon_args()
3694 
    args.read(iprot)
3695 
    iprot.readMessageEnd()
3696 
    result = removeCoupon_result()
3697 
    try:
3698 
      self._handler.removeCoupon(args.cartId)
3699 
    except ShoppingCartException, scx:
3700 
      result.scx = scx
3701 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3702 
    result.write(oprot)
3703 
    oprot.writeMessageEnd()
3704 
    oprot.trans.flush()
3705 
 
690 chandransh 3706 
  def process_createOrders(self, seqid, iprot, oprot):
3707 
    args = createOrders_args()
559 chandransh 3708 
    args.read(iprot)
3709 
    iprot.readMessageEnd()
690 chandransh 3710 
    result = createOrders_result()
559 chandransh 3711 
    try:
2815 vikas 3712 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3713 
    except ShoppingCartException, scx:
3714 
      result.scx = scx
690 chandransh 3715 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3716 
    result.write(oprot)
3717 
    oprot.writeMessageEnd()
3718 
    oprot.trans.flush()
3719 
 
3720 
  def process_validateCart(self, seqid, iprot, oprot):
3721 
    args = validateCart_args()
3722 
    args.read(iprot)
3723 
    iprot.readMessageEnd()
3724 
    result = validateCart_result()
575 chandransh 3725 
    try:
3726 
      result.success = self._handler.validateCart(args.cartId)
3727 
    except ShoppingCartException, scex:
3728 
      result.scex = scex
559 chandransh 3729 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3730 
    result.write(oprot)
3731 
    oprot.writeMessageEnd()
3732 
    oprot.trans.flush()
3733 
 
690 chandransh 3734 
  def process_mergeCart(self, seqid, iprot, oprot):
3735 
    args = mergeCart_args()
575 chandransh 3736 
    args.read(iprot)
3737 
    iprot.readMessageEnd()
690 chandransh 3738 
    result = mergeCart_result()
3739 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3740 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3741 
    result.write(oprot)
3742 
    oprot.writeMessageEnd()
3743 
    oprot.trans.flush()
3744 
 
3745 
  def process_checkOut(self, seqid, iprot, oprot):
3746 
    args = checkOut_args()
3747 
    args.read(iprot)
3748 
    iprot.readMessageEnd()
3749 
    result = checkOut_result()
575 chandransh 3750 
    try:
690 chandransh 3751 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3752 
    except ShoppingCartException, scex:
3753 
      result.scex = scex
690 chandransh 3754 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3755 
    result.write(oprot)
3756 
    oprot.writeMessageEnd()
3757 
    oprot.trans.flush()
3758 
 
690 chandransh 3759 
  def process_resetCart(self, seqid, iprot, oprot):
3760 
    args = resetCart_args()
559 chandransh 3761 
    args.read(iprot)
3762 
    iprot.readMessageEnd()
690 chandransh 3763 
    result = resetCart_result()
3764 
    try:
3765 
      result.success = self._handler.resetCart(args.cartId, args.items)
3766 
    except ShoppingCartException, scex:
3767 
      result.scex = scex
3768 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3769 
    result.write(oprot)
3770 
    oprot.writeMessageEnd()
3771 
    oprot.trans.flush()
3772 
 
2981 rajveer 3773 
  def process_getUserCount(self, seqid, iprot, oprot):
3774 
    args = getUserCount_args()
559 chandransh 3775 
    args.read(iprot)
3776 
    iprot.readMessageEnd()
2981 rajveer 3777 
    result = getUserCount_result()
3778 
    result.success = self._handler.getUserCount(args.userType)
3779 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3780 
    result.write(oprot)
3781 
    oprot.writeMessageEnd()
3782 
    oprot.trans.flush()
3783 
 
2981 rajveer 3784 
  def process_getAllUsers(self, seqid, iprot, oprot):
3785 
    args = getAllUsers_args()
559 chandransh 3786 
    args.read(iprot)
3787 
    iprot.readMessageEnd()
2981 rajveer 3788 
    result = getAllUsers_result()
3789 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3790 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3791 
    result.write(oprot)
3792 
    oprot.writeMessageEnd()
3793 
    oprot.trans.flush()
3794 
 
2981 rajveer 3795 
  def process_putUserNote(self, seqid, iprot, oprot):
3796 
    args = putUserNote_args()
559 chandransh 3797 
    args.read(iprot)
3798 
    iprot.readMessageEnd()
2981 rajveer 3799 
    result = putUserNote_result()
3800 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
3801 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
559 chandransh 3802 
    result.write(oprot)
3803 
    oprot.writeMessageEnd()
3804 
    oprot.trans.flush()
3805 
 
2981 rajveer 3806 
  def process_getUserNotes(self, seqid, iprot, oprot):
3807 
    args = getUserNotes_args()
559 chandransh 3808 
    args.read(iprot)
3809 
    iprot.readMessageEnd()
2981 rajveer 3810 
    result = getUserNotes_result()
3811 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3812 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
559 chandransh 3813 
    result.write(oprot)
3814 
    oprot.writeMessageEnd()
3815 
    oprot.trans.flush()
3816 
 
2981 rajveer 3817 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3818 
    args = getMyResearchItems_args()
559 chandransh 3819 
    args.read(iprot)
3820 
    iprot.readMessageEnd()
2981 rajveer 3821 
    result = getMyResearchItems_result()
559 chandransh 3822 
    try:
2981 rajveer 3823 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3824 
    except WidgetException, scx:
3825 
      result.scx = scx
2981 rajveer 3826 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3827 
    result.write(oprot)
3828 
    oprot.writeMessageEnd()
3829 
    oprot.trans.flush()
3830 
 
2981 rajveer 3831 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3832 
    args = updateMyResearch_args()
772 rajveer 3833 
    args.read(iprot)
3834 
    iprot.readMessageEnd()
2981 rajveer 3835 
    result = updateMyResearch_result()
3836 
    try:
3837 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3838 
    except WidgetException, scx:
3839 
      result.scx = scx
3840 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3841 
    result.write(oprot)
3842 
    oprot.writeMessageEnd()
3843 
    oprot.trans.flush()
559 chandransh 3844 
 
2981 rajveer 3845 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3846 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3847 
    args.read(iprot)
3848 
    iprot.readMessageEnd()
2981 rajveer 3849 
    result = deleteItemFromMyResearch_result()
3850 
    try:
3851 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3852 
    except WidgetException, scx:
3853 
      result.scx = scx
3854 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
772 rajveer 3858 
 
2981 rajveer 3859 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3860 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
2981 rajveer 3863 
    result = getBrowseHistoryItems_result()
3864 
    try:
3865 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3866 
    except WidgetException, scx:
3867 
      result.scx = scx
3868 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3869 
    result.write(oprot)
3870 
    oprot.writeMessageEnd()
3871 
    oprot.trans.flush()
1596 ankur.sing 3872 
 
2981 rajveer 3873 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3874 
    args = updateBrowseHistory_args()
2642 varun.gupt 3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
2981 rajveer 3877 
    result = updateBrowseHistory_result()
3878 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
3879 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 3880 
    result.write(oprot)
3881 
    oprot.writeMessageEnd()
3882 
    oprot.trans.flush()
1673 ankur.sing 3883 
 
2642 varun.gupt 3884 
 
94 ashish 3885 
# HELPER FUNCTIONS AND STRUCTURES
3886 
 
765 rajveer 3887 
class closeSession_args:
3888 
 
3889 
  thrift_spec = (
3890 
  )
3891 
 
3892 
  def read(self, iprot):
3893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3895 
      return
3896 
    iprot.readStructBegin()
3897 
    while True:
3898 
      (fname, ftype, fid) = iprot.readFieldBegin()
3899 
      if ftype == TType.STOP:
3900 
        break
3901 
      else:
3902 
        iprot.skip(ftype)
3903 
      iprot.readFieldEnd()
3904 
    iprot.readStructEnd()
3905 
 
3906 
  def write(self, oprot):
3907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3909 
      return
3910 
    oprot.writeStructBegin('closeSession_args')
3911 
    oprot.writeFieldStop()
3912 
    oprot.writeStructEnd()
3913 
 
3914 
  def __repr__(self):
3915 
    L = ['%s=%r' % (key, value)
3916 
      for key, value in self.__dict__.iteritems()]
3917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3918 
 
3919 
  def __eq__(self, other):
3920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3921 
 
3922 
  def __ne__(self, other):
3923 
    return not (self == other)
3924 
 
3925 
class closeSession_result:
3926 
 
3927 
  thrift_spec = (
3928 
  )
3929 
 
3930 
  def read(self, iprot):
3931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3933 
      return
3934 
    iprot.readStructBegin()
3935 
    while True:
3936 
      (fname, ftype, fid) = iprot.readFieldBegin()
3937 
      if ftype == TType.STOP:
3938 
        break
3939 
      else:
3940 
        iprot.skip(ftype)
3941 
      iprot.readFieldEnd()
3942 
    iprot.readStructEnd()
3943 
 
3944 
  def write(self, oprot):
3945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3947 
      return
3948 
    oprot.writeStructBegin('closeSession_result')
3949 
    oprot.writeFieldStop()
3950 
    oprot.writeStructEnd()
3951 
 
3952 
  def __repr__(self):
3953 
    L = ['%s=%r' % (key, value)
3954 
      for key, value in self.__dict__.iteritems()]
3955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3956 
 
3957 
  def __eq__(self, other):
3958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3959 
 
3960 
  def __ne__(self, other):
3961 
    return not (self == other)
3962 
 
559 chandransh 3963 
class createAnonymousUser_args:
94 ashish 3964 
  """
3965 
  Attributes:
559 chandransh 3966 
   - jsessionId
94 ashish 3967 
  """
3968 
 
3969 
  thrift_spec = (
3970 
    None, # 0
559 chandransh 3971 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3972 
  )
3973 
 
559 chandransh 3974 
  def __init__(self, jsessionId=None,):
3975 
    self.jsessionId = jsessionId
94 ashish 3976 
 
3977 
  def read(self, iprot):
3978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3980 
      return
3981 
    iprot.readStructBegin()
3982 
    while True:
3983 
      (fname, ftype, fid) = iprot.readFieldBegin()
3984 
      if ftype == TType.STOP:
3985 
        break
3986 
      if fid == 1:
559 chandransh 3987 
        if ftype == TType.STRING:
3988 
          self.jsessionId = iprot.readString();
94 ashish 3989 
        else:
3990 
          iprot.skip(ftype)
3991 
      else:
3992 
        iprot.skip(ftype)
3993 
      iprot.readFieldEnd()
3994 
    iprot.readStructEnd()
3995 
 
3996 
  def write(self, oprot):
3997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3999 
      return
559 chandransh 4000 
    oprot.writeStructBegin('createAnonymousUser_args')
4001 
    if self.jsessionId != None:
4002 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4003 
      oprot.writeString(self.jsessionId)
94 ashish 4004 
      oprot.writeFieldEnd()
4005 
    oprot.writeFieldStop()
4006 
    oprot.writeStructEnd()
4007 
 
4008 
  def __repr__(self):
4009 
    L = ['%s=%r' % (key, value)
4010 
      for key, value in self.__dict__.iteritems()]
4011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4012 
 
4013 
  def __eq__(self, other):
4014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4015 
 
4016 
  def __ne__(self, other):
4017 
    return not (self == other)
4018 
 
559 chandransh 4019 
class createAnonymousUser_result:
94 ashish 4020 
  """
4021 
  Attributes:
4022 
   - success
559 chandransh 4023 
   - ucex
94 ashish 4024 
  """
4025 
 
4026 
  thrift_spec = (
559 chandransh 4027 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4028 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4029 
  )
4030 
 
559 chandransh 4031 
  def __init__(self, success=None, ucex=None,):
94 ashish 4032 
    self.success = success
559 chandransh 4033 
    self.ucex = ucex
94 ashish 4034 
 
4035 
  def read(self, iprot):
4036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4038 
      return
4039 
    iprot.readStructBegin()
4040 
    while True:
4041 
      (fname, ftype, fid) = iprot.readFieldBegin()
4042 
      if ftype == TType.STOP:
4043 
        break
4044 
      if fid == 0:
4045 
        if ftype == TType.STRUCT:
559 chandransh 4046 
          self.success = User()
94 ashish 4047 
          self.success.read(iprot)
4048 
        else:
4049 
          iprot.skip(ftype)
4050 
      elif fid == 1:
4051 
        if ftype == TType.STRUCT:
559 chandransh 4052 
          self.ucex = UserContextException()
4053 
          self.ucex.read(iprot)
94 ashish 4054 
        else:
4055 
          iprot.skip(ftype)
4056 
      else:
4057 
        iprot.skip(ftype)
4058 
      iprot.readFieldEnd()
4059 
    iprot.readStructEnd()
4060 
 
4061 
  def write(self, oprot):
4062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4064 
      return
559 chandransh 4065 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4066 
    if self.success != None:
4067 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4068 
      self.success.write(oprot)
4069 
      oprot.writeFieldEnd()
559 chandransh 4070 
    if self.ucex != None:
4071 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4072 
      self.ucex.write(oprot)
94 ashish 4073 
      oprot.writeFieldEnd()
4074 
    oprot.writeFieldStop()
4075 
    oprot.writeStructEnd()
4076 
 
4077 
  def __repr__(self):
4078 
    L = ['%s=%r' % (key, value)
4079 
      for key, value in self.__dict__.iteritems()]
4080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4081 
 
4082 
  def __eq__(self, other):
4083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4084 
 
4085 
  def __ne__(self, other):
4086 
    return not (self == other)
4087 
 
559 chandransh 4088 
class getUserById_args:
94 ashish 4089 
  """
4090 
  Attributes:
4091 
   - userId
4092 
  """
4093 
 
4094 
  thrift_spec = (
4095 
    None, # 0
4096 
    (1, TType.I64, 'userId', None, None, ), # 1
4097 
  )
4098 
 
559 chandransh 4099 
  def __init__(self, userId=None,):
94 ashish 4100 
    self.userId = userId
4101 
 
4102 
  def read(self, iprot):
4103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4105 
      return
4106 
    iprot.readStructBegin()
4107 
    while True:
4108 
      (fname, ftype, fid) = iprot.readFieldBegin()
4109 
      if ftype == TType.STOP:
4110 
        break
4111 
      if fid == 1:
4112 
        if ftype == TType.I64:
4113 
          self.userId = iprot.readI64();
4114 
        else:
4115 
          iprot.skip(ftype)
4116 
      else:
4117 
        iprot.skip(ftype)
4118 
      iprot.readFieldEnd()
4119 
    iprot.readStructEnd()
4120 
 
4121 
  def write(self, oprot):
4122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4124 
      return
559 chandransh 4125 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4126 
    if self.userId != None:
4127 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4128 
      oprot.writeI64(self.userId)
4129 
      oprot.writeFieldEnd()
4130 
    oprot.writeFieldStop()
4131 
    oprot.writeStructEnd()
4132 
 
4133 
  def __repr__(self):
4134 
    L = ['%s=%r' % (key, value)
4135 
      for key, value in self.__dict__.iteritems()]
4136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4137 
 
4138 
  def __eq__(self, other):
4139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4140 
 
4141 
  def __ne__(self, other):
4142 
    return not (self == other)
4143 
 
559 chandransh 4144 
class getUserById_result:
94 ashish 4145 
  """
4146 
  Attributes:
4147 
   - success
559 chandransh 4148 
   - ucex
94 ashish 4149 
  """
4150 
 
4151 
  thrift_spec = (
559 chandransh 4152 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4153 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4154 
  )
4155 
 
559 chandransh 4156 
  def __init__(self, success=None, ucex=None,):
94 ashish 4157 
    self.success = success
559 chandransh 4158 
    self.ucex = ucex
94 ashish 4159 
 
4160 
  def read(self, iprot):
4161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4163 
      return
4164 
    iprot.readStructBegin()
4165 
    while True:
4166 
      (fname, ftype, fid) = iprot.readFieldBegin()
4167 
      if ftype == TType.STOP:
4168 
        break
4169 
      if fid == 0:
4170 
        if ftype == TType.STRUCT:
559 chandransh 4171 
          self.success = User()
94 ashish 4172 
          self.success.read(iprot)
4173 
        else:
4174 
          iprot.skip(ftype)
4175 
      elif fid == 1:
4176 
        if ftype == TType.STRUCT:
559 chandransh 4177 
          self.ucex = UserContextException()
4178 
          self.ucex.read(iprot)
94 ashish 4179 
        else:
4180 
          iprot.skip(ftype)
4181 
      else:
4182 
        iprot.skip(ftype)
4183 
      iprot.readFieldEnd()
4184 
    iprot.readStructEnd()
4185 
 
4186 
  def write(self, oprot):
4187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4189 
      return
559 chandransh 4190 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4191 
    if self.success != None:
4192 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4193 
      self.success.write(oprot)
4194 
      oprot.writeFieldEnd()
559 chandransh 4195 
    if self.ucex != None:
4196 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4197 
      self.ucex.write(oprot)
94 ashish 4198 
      oprot.writeFieldEnd()
4199 
    oprot.writeFieldStop()
4200 
    oprot.writeStructEnd()
4201 
 
4202 
  def __repr__(self):
4203 
    L = ['%s=%r' % (key, value)
4204 
      for key, value in self.__dict__.iteritems()]
4205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4206 
 
4207 
  def __eq__(self, other):
4208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4209 
 
4210 
  def __ne__(self, other):
4211 
    return not (self == other)
4212 
 
1491 vikas 4213 
class getUserByEmail_args:
4214 
  """
4215 
  Attributes:
4216 
   - email
4217 
  """
4218 
 
4219 
  thrift_spec = (
4220 
    None, # 0
4221 
    (1, TType.STRING, 'email', None, None, ), # 1
4222 
  )
4223 
 
4224 
  def __init__(self, email=None,):
4225 
    self.email = email
4226 
 
4227 
  def read(self, iprot):
4228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4230 
      return
4231 
    iprot.readStructBegin()
4232 
    while True:
4233 
      (fname, ftype, fid) = iprot.readFieldBegin()
4234 
      if ftype == TType.STOP:
4235 
        break
4236 
      if fid == 1:
4237 
        if ftype == TType.STRING:
4238 
          self.email = iprot.readString();
4239 
        else:
4240 
          iprot.skip(ftype)
4241 
      else:
4242 
        iprot.skip(ftype)
4243 
      iprot.readFieldEnd()
4244 
    iprot.readStructEnd()
4245 
 
4246 
  def write(self, oprot):
4247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4249 
      return
4250 
    oprot.writeStructBegin('getUserByEmail_args')
4251 
    if self.email != None:
4252 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4253 
      oprot.writeString(self.email)
4254 
      oprot.writeFieldEnd()
4255 
    oprot.writeFieldStop()
4256 
    oprot.writeStructEnd()
4257 
 
4258 
  def __repr__(self):
4259 
    L = ['%s=%r' % (key, value)
4260 
      for key, value in self.__dict__.iteritems()]
4261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4262 
 
4263 
  def __eq__(self, other):
4264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4265 
 
4266 
  def __ne__(self, other):
4267 
    return not (self == other)
4268 
 
4269 
class getUserByEmail_result:
4270 
  """
4271 
  Attributes:
4272 
   - success
4273 
   - ucex
4274 
  """
4275 
 
4276 
  thrift_spec = (
4277 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4278 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4279 
  )
4280 
 
4281 
  def __init__(self, success=None, ucex=None,):
4282 
    self.success = success
4283 
    self.ucex = ucex
4284 
 
4285 
  def read(self, iprot):
4286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4288 
      return
4289 
    iprot.readStructBegin()
4290 
    while True:
4291 
      (fname, ftype, fid) = iprot.readFieldBegin()
4292 
      if ftype == TType.STOP:
4293 
        break
4294 
      if fid == 0:
4295 
        if ftype == TType.STRUCT:
4296 
          self.success = User()
4297 
          self.success.read(iprot)
4298 
        else:
4299 
          iprot.skip(ftype)
4300 
      elif fid == 1:
4301 
        if ftype == TType.STRUCT:
4302 
          self.ucex = UserContextException()
4303 
          self.ucex.read(iprot)
4304 
        else:
4305 
          iprot.skip(ftype)
4306 
      else:
4307 
        iprot.skip(ftype)
4308 
      iprot.readFieldEnd()
4309 
    iprot.readStructEnd()
4310 
 
4311 
  def write(self, oprot):
4312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4314 
      return
4315 
    oprot.writeStructBegin('getUserByEmail_result')
4316 
    if self.success != None:
4317 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4318 
      self.success.write(oprot)
4319 
      oprot.writeFieldEnd()
4320 
    if self.ucex != None:
4321 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4322 
      self.ucex.write(oprot)
4323 
      oprot.writeFieldEnd()
4324 
    oprot.writeFieldStop()
4325 
    oprot.writeStructEnd()
4326 
 
4327 
  def __repr__(self):
4328 
    L = ['%s=%r' % (key, value)
4329 
      for key, value in self.__dict__.iteritems()]
4330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4331 
 
4332 
  def __eq__(self, other):
4333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4334 
 
4335 
  def __ne__(self, other):
4336 
    return not (self == other)
4337 
 
3032 mandeep.dh 4338 
class getUserByMobileNumber_args:
4339 
  """
4340 
  Attributes:
4341 
   - mobileNumber
4342 
  """
4343 
 
4344 
  thrift_spec = (
4345 
    None, # 0
4346 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
4347 
  )
4348 
 
4349 
  def __init__(self, mobileNumber=None,):
4350 
    self.mobileNumber = mobileNumber
4351 
 
4352 
  def read(self, iprot):
4353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4355 
      return
4356 
    iprot.readStructBegin()
4357 
    while True:
4358 
      (fname, ftype, fid) = iprot.readFieldBegin()
4359 
      if ftype == TType.STOP:
4360 
        break
4361 
      if fid == 1:
4362 
        if ftype == TType.I64:
4363 
          self.mobileNumber = iprot.readI64();
4364 
        else:
4365 
          iprot.skip(ftype)
4366 
      else:
4367 
        iprot.skip(ftype)
4368 
      iprot.readFieldEnd()
4369 
    iprot.readStructEnd()
4370 
 
4371 
  def write(self, oprot):
4372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4374 
      return
4375 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4376 
    if self.mobileNumber != None:
4377 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4378 
      oprot.writeI64(self.mobileNumber)
4379 
      oprot.writeFieldEnd()
4380 
    oprot.writeFieldStop()
4381 
    oprot.writeStructEnd()
4382 
 
4383 
  def __repr__(self):
4384 
    L = ['%s=%r' % (key, value)
4385 
      for key, value in self.__dict__.iteritems()]
4386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4387 
 
4388 
  def __eq__(self, other):
4389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4390 
 
4391 
  def __ne__(self, other):
4392 
    return not (self == other)
4393 
 
4394 
class getUserByMobileNumber_result:
4395 
  """
4396 
  Attributes:
4397 
   - success
4398 
   - ucex
4399 
  """
4400 
 
4401 
  thrift_spec = (
4402 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4403 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4404 
  )
4405 
 
4406 
  def __init__(self, success=None, ucex=None,):
4407 
    self.success = success
4408 
    self.ucex = ucex
4409 
 
4410 
  def read(self, iprot):
4411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4413 
      return
4414 
    iprot.readStructBegin()
4415 
    while True:
4416 
      (fname, ftype, fid) = iprot.readFieldBegin()
4417 
      if ftype == TType.STOP:
4418 
        break
4419 
      if fid == 0:
4420 
        if ftype == TType.STRUCT:
4421 
          self.success = User()
4422 
          self.success.read(iprot)
4423 
        else:
4424 
          iprot.skip(ftype)
4425 
      elif fid == 1:
4426 
        if ftype == TType.STRUCT:
4427 
          self.ucex = UserContextException()
4428 
          self.ucex.read(iprot)
4429 
        else:
4430 
          iprot.skip(ftype)
4431 
      else:
4432 
        iprot.skip(ftype)
4433 
      iprot.readFieldEnd()
4434 
    iprot.readStructEnd()
4435 
 
4436 
  def write(self, oprot):
4437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4439 
      return
4440 
    oprot.writeStructBegin('getUserByMobileNumber_result')
4441 
    if self.success != None:
4442 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4443 
      self.success.write(oprot)
4444 
      oprot.writeFieldEnd()
4445 
    if self.ucex != None:
4446 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4447 
      self.ucex.write(oprot)
4448 
      oprot.writeFieldEnd()
4449 
    oprot.writeFieldStop()
4450 
    oprot.writeStructEnd()
4451 
 
4452 
  def __repr__(self):
4453 
    L = ['%s=%r' % (key, value)
4454 
      for key, value in self.__dict__.iteritems()]
4455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4456 
 
4457 
  def __eq__(self, other):
4458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4459 
 
4460 
  def __ne__(self, other):
4461 
    return not (self == other)
4462 
 
559 chandransh 4463 
class createUser_args:
94 ashish 4464 
  """
4465 
  Attributes:
559 chandransh 4466 
   - user
94 ashish 4467 
  """
4468 
 
4469 
  thrift_spec = (
4470 
    None, # 0
559 chandransh 4471 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4472 
  )
4473 
 
559 chandransh 4474 
  def __init__(self, user=None,):
4475 
    self.user = user
94 ashish 4476 
 
4477 
  def read(self, iprot):
4478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4480 
      return
4481 
    iprot.readStructBegin()
4482 
    while True:
4483 
      (fname, ftype, fid) = iprot.readFieldBegin()
4484 
      if ftype == TType.STOP:
4485 
        break
4486 
      if fid == 1:
559 chandransh 4487 
        if ftype == TType.STRUCT:
4488 
          self.user = User()
4489 
          self.user.read(iprot)
94 ashish 4490 
        else:
4491 
          iprot.skip(ftype)
4492 
      else:
4493 
        iprot.skip(ftype)
4494 
      iprot.readFieldEnd()
4495 
    iprot.readStructEnd()
4496 
 
4497 
  def write(self, oprot):
4498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4500 
      return
559 chandransh 4501 
    oprot.writeStructBegin('createUser_args')
4502 
    if self.user != None:
4503 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4504 
      self.user.write(oprot)
94 ashish 4505 
      oprot.writeFieldEnd()
4506 
    oprot.writeFieldStop()
4507 
    oprot.writeStructEnd()
4508 
 
4509 
  def __repr__(self):
4510 
    L = ['%s=%r' % (key, value)
4511 
      for key, value in self.__dict__.iteritems()]
4512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4513 
 
4514 
  def __eq__(self, other):
4515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4516 
 
4517 
  def __ne__(self, other):
4518 
    return not (self == other)
4519 
 
559 chandransh 4520 
class createUser_result:
94 ashish 4521 
  """
4522 
  Attributes:
4523 
   - success
559 chandransh 4524 
   - ucex
94 ashish 4525 
  """
4526 
 
4527 
  thrift_spec = (
559 chandransh 4528 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4529 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4530 
  )
4531 
 
559 chandransh 4532 
  def __init__(self, success=None, ucex=None,):
94 ashish 4533 
    self.success = success
559 chandransh 4534 
    self.ucex = ucex
94 ashish 4535 
 
4536 
  def read(self, iprot):
4537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4539 
      return
4540 
    iprot.readStructBegin()
4541 
    while True:
4542 
      (fname, ftype, fid) = iprot.readFieldBegin()
4543 
      if ftype == TType.STOP:
4544 
        break
4545 
      if fid == 0:
4546 
        if ftype == TType.STRUCT:
559 chandransh 4547 
          self.success = User()
94 ashish 4548 
          self.success.read(iprot)
4549 
        else:
4550 
          iprot.skip(ftype)
4551 
      elif fid == 1:
4552 
        if ftype == TType.STRUCT:
559 chandransh 4553 
          self.ucex = UserContextException()
4554 
          self.ucex.read(iprot)
94 ashish 4555 
        else:
4556 
          iprot.skip(ftype)
4557 
      else:
4558 
        iprot.skip(ftype)
4559 
      iprot.readFieldEnd()
4560 
    iprot.readStructEnd()
4561 
 
4562 
  def write(self, oprot):
4563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4565 
      return
559 chandransh 4566 
    oprot.writeStructBegin('createUser_result')
94 ashish 4567 
    if self.success != None:
4568 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4569 
      self.success.write(oprot)
4570 
      oprot.writeFieldEnd()
559 chandransh 4571 
    if self.ucex != None:
4572 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4573 
      self.ucex.write(oprot)
94 ashish 4574 
      oprot.writeFieldEnd()
4575 
    oprot.writeFieldStop()
4576 
    oprot.writeStructEnd()
4577 
 
4578 
  def __repr__(self):
4579 
    L = ['%s=%r' % (key, value)
4580 
      for key, value in self.__dict__.iteritems()]
4581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4582 
 
4583 
  def __eq__(self, other):
4584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4585 
 
4586 
  def __ne__(self, other):
4587 
    return not (self == other)
4588 
 
559 chandransh 4589 
class updateUser_args:
94 ashish 4590 
  """
4591 
  Attributes:
559 chandransh 4592 
   - user
94 ashish 4593 
  """
4594 
 
4595 
  thrift_spec = (
4596 
    None, # 0
559 chandransh 4597 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4598 
  )
4599 
 
559 chandransh 4600 
  def __init__(self, user=None,):
4601 
    self.user = user
94 ashish 4602 
 
4603 
  def read(self, iprot):
4604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4606 
      return
4607 
    iprot.readStructBegin()
4608 
    while True:
4609 
      (fname, ftype, fid) = iprot.readFieldBegin()
4610 
      if ftype == TType.STOP:
4611 
        break
4612 
      if fid == 1:
559 chandransh 4613 
        if ftype == TType.STRUCT:
4614 
          self.user = User()
4615 
          self.user.read(iprot)
94 ashish 4616 
        else:
4617 
          iprot.skip(ftype)
4618 
      else:
4619 
        iprot.skip(ftype)
4620 
      iprot.readFieldEnd()
4621 
    iprot.readStructEnd()
4622 
 
4623 
  def write(self, oprot):
4624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4626 
      return
559 chandransh 4627 
    oprot.writeStructBegin('updateUser_args')
4628 
    if self.user != None:
4629 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4630 
      self.user.write(oprot)
94 ashish 4631 
      oprot.writeFieldEnd()
4632 
    oprot.writeFieldStop()
4633 
    oprot.writeStructEnd()
4634 
 
4635 
  def __repr__(self):
4636 
    L = ['%s=%r' % (key, value)
4637 
      for key, value in self.__dict__.iteritems()]
4638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4639 
 
4640 
  def __eq__(self, other):
4641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4642 
 
4643 
  def __ne__(self, other):
4644 
    return not (self == other)
4645 
 
559 chandransh 4646 
class updateUser_result:
94 ashish 4647 
  """
4648 
  Attributes:
4649 
   - success
559 chandransh 4650 
   - ucex
94 ashish 4651 
  """
4652 
 
4653 
  thrift_spec = (
559 chandransh 4654 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4655 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4656 
  )
4657 
 
559 chandransh 4658 
  def __init__(self, success=None, ucex=None,):
94 ashish 4659 
    self.success = success
559 chandransh 4660 
    self.ucex = ucex
94 ashish 4661 
 
4662 
  def read(self, iprot):
4663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4665 
      return
4666 
    iprot.readStructBegin()
4667 
    while True:
4668 
      (fname, ftype, fid) = iprot.readFieldBegin()
4669 
      if ftype == TType.STOP:
4670 
        break
4671 
      if fid == 0:
4672 
        if ftype == TType.STRUCT:
559 chandransh 4673 
          self.success = User()
94 ashish 4674 
          self.success.read(iprot)
4675 
        else:
4676 
          iprot.skip(ftype)
4677 
      elif fid == 1:
4678 
        if ftype == TType.STRUCT:
559 chandransh 4679 
          self.ucex = UserContextException()
4680 
          self.ucex.read(iprot)
94 ashish 4681 
        else:
4682 
          iprot.skip(ftype)
4683 
      else:
4684 
        iprot.skip(ftype)
4685 
      iprot.readFieldEnd()
4686 
    iprot.readStructEnd()
4687 
 
4688 
  def write(self, oprot):
4689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4691 
      return
559 chandransh 4692 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4693 
    if self.success != None:
4694 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4695 
      self.success.write(oprot)
4696 
      oprot.writeFieldEnd()
559 chandransh 4697 
    if self.ucex != None:
4698 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4699 
      self.ucex.write(oprot)
94 ashish 4700 
      oprot.writeFieldEnd()
4701 
    oprot.writeFieldStop()
4702 
    oprot.writeStructEnd()
4703 
 
4704 
  def __repr__(self):
4705 
    L = ['%s=%r' % (key, value)
4706 
      for key, value in self.__dict__.iteritems()]
4707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4708 
 
4709 
  def __eq__(self, other):
4710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4711 
 
4712 
  def __ne__(self, other):
4713 
    return not (self == other)
4714 
 
559 chandransh 4715 
class deleteUser_args:
94 ashish 4716 
  """
4717 
  Attributes:
4718 
   - userId
4719 
  """
4720 
 
4721 
  thrift_spec = (
4722 
    None, # 0
4723 
    (1, TType.I64, 'userId', None, None, ), # 1
4724 
  )
4725 
 
559 chandransh 4726 
  def __init__(self, userId=None,):
94 ashish 4727 
    self.userId = userId
4728 
 
4729 
  def read(self, iprot):
4730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4732 
      return
4733 
    iprot.readStructBegin()
4734 
    while True:
4735 
      (fname, ftype, fid) = iprot.readFieldBegin()
4736 
      if ftype == TType.STOP:
4737 
        break
4738 
      if fid == 1:
4739 
        if ftype == TType.I64:
4740 
          self.userId = iprot.readI64();
4741 
        else:
4742 
          iprot.skip(ftype)
4743 
      else:
4744 
        iprot.skip(ftype)
4745 
      iprot.readFieldEnd()
4746 
    iprot.readStructEnd()
4747 
 
4748 
  def write(self, oprot):
4749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4751 
      return
559 chandransh 4752 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4753 
    if self.userId != None:
4754 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4755 
      oprot.writeI64(self.userId)
4756 
      oprot.writeFieldEnd()
4757 
    oprot.writeFieldStop()
4758 
    oprot.writeStructEnd()
4759 
 
4760 
  def __repr__(self):
4761 
    L = ['%s=%r' % (key, value)
4762 
      for key, value in self.__dict__.iteritems()]
4763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4764 
 
4765 
  def __eq__(self, other):
4766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4767 
 
4768 
  def __ne__(self, other):
4769 
    return not (self == other)
4770 
 
559 chandransh 4771 
class deleteUser_result:
94 ashish 4772 
  """
4773 
  Attributes:
4774 
   - success
559 chandransh 4775 
   - ucex
94 ashish 4776 
  """
4777 
 
4778 
  thrift_spec = (
559 chandransh 4779 
    (0, TType.BOOL, 'success', None, None, ), # 0
4780 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4781 
  )
4782 
 
559 chandransh 4783 
  def __init__(self, success=None, ucex=None,):
94 ashish 4784 
    self.success = success
559 chandransh 4785 
    self.ucex = ucex
94 ashish 4786 
 
4787 
  def read(self, iprot):
4788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4790 
      return
4791 
    iprot.readStructBegin()
4792 
    while True:
4793 
      (fname, ftype, fid) = iprot.readFieldBegin()
4794 
      if ftype == TType.STOP:
4795 
        break
4796 
      if fid == 0:
559 chandransh 4797 
        if ftype == TType.BOOL:
4798 
          self.success = iprot.readBool();
94 ashish 4799 
        else:
4800 
          iprot.skip(ftype)
4801 
      elif fid == 1:
4802 
        if ftype == TType.STRUCT:
559 chandransh 4803 
          self.ucex = UserContextException()
4804 
          self.ucex.read(iprot)
94 ashish 4805 
        else:
4806 
          iprot.skip(ftype)
4807 
      else:
4808 
        iprot.skip(ftype)
4809 
      iprot.readFieldEnd()
4810 
    iprot.readStructEnd()
4811 
 
4812 
  def write(self, oprot):
4813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4815 
      return
559 chandransh 4816 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4817 
    if self.success != None:
559 chandransh 4818 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4819 
      oprot.writeBool(self.success)
94 ashish 4820 
      oprot.writeFieldEnd()
559 chandransh 4821 
    if self.ucex != None:
4822 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4823 
      self.ucex.write(oprot)
94 ashish 4824 
      oprot.writeFieldEnd()
4825 
    oprot.writeFieldStop()
4826 
    oprot.writeStructEnd()
4827 
 
4828 
  def __repr__(self):
4829 
    L = ['%s=%r' % (key, value)
4830 
      for key, value in self.__dict__.iteritems()]
4831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4832 
 
4833 
  def __eq__(self, other):
4834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4835 
 
4836 
  def __ne__(self, other):
4837 
    return not (self == other)
4838 
 
559 chandransh 4839 
class getUserState_args:
94 ashish 4840 
  """
4841 
  Attributes:
4842 
   - userId
4843 
  """
4844 
 
4845 
  thrift_spec = (
4846 
    None, # 0
4847 
    (1, TType.I64, 'userId', None, None, ), # 1
4848 
  )
4849 
 
559 chandransh 4850 
  def __init__(self, userId=None,):
94 ashish 4851 
    self.userId = userId
4852 
 
4853 
  def read(self, iprot):
4854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4856 
      return
4857 
    iprot.readStructBegin()
4858 
    while True:
4859 
      (fname, ftype, fid) = iprot.readFieldBegin()
4860 
      if ftype == TType.STOP:
4861 
        break
4862 
      if fid == 1:
4863 
        if ftype == TType.I64:
4864 
          self.userId = iprot.readI64();
4865 
        else:
4866 
          iprot.skip(ftype)
4867 
      else:
4868 
        iprot.skip(ftype)
4869 
      iprot.readFieldEnd()
4870 
    iprot.readStructEnd()
4871 
 
4872 
  def write(self, oprot):
4873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4875 
      return
559 chandransh 4876 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4877 
    if self.userId != None:
4878 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4879 
      oprot.writeI64(self.userId)
4880 
      oprot.writeFieldEnd()
4881 
    oprot.writeFieldStop()
4882 
    oprot.writeStructEnd()
4883 
 
4884 
  def __repr__(self):
4885 
    L = ['%s=%r' % (key, value)
4886 
      for key, value in self.__dict__.iteritems()]
4887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4888 
 
4889 
  def __eq__(self, other):
4890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4891 
 
4892 
  def __ne__(self, other):
4893 
    return not (self == other)
4894 
 
559 chandransh 4895 
class getUserState_result:
94 ashish 4896 
  """
4897 
  Attributes:
4898 
   - success
559 chandransh 4899 
   - ucex
94 ashish 4900 
  """
4901 
 
4902 
  thrift_spec = (
559 chandransh 4903 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4904 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4905 
  )
4906 
 
559 chandransh 4907 
  def __init__(self, success=None, ucex=None,):
94 ashish 4908 
    self.success = success
559 chandransh 4909 
    self.ucex = ucex
94 ashish 4910 
 
4911 
  def read(self, iprot):
4912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4914 
      return
4915 
    iprot.readStructBegin()
4916 
    while True:
4917 
      (fname, ftype, fid) = iprot.readFieldBegin()
4918 
      if ftype == TType.STOP:
4919 
        break
4920 
      if fid == 0:
4921 
        if ftype == TType.STRUCT:
559 chandransh 4922 
          self.success = UserState()
94 ashish 4923 
          self.success.read(iprot)
4924 
        else:
4925 
          iprot.skip(ftype)
4926 
      elif fid == 1:
4927 
        if ftype == TType.STRUCT:
559 chandransh 4928 
          self.ucex = UserContextException()
4929 
          self.ucex.read(iprot)
94 ashish 4930 
        else:
4931 
          iprot.skip(ftype)
4932 
      else:
4933 
        iprot.skip(ftype)
4934 
      iprot.readFieldEnd()
4935 
    iprot.readStructEnd()
4936 
 
4937 
  def write(self, oprot):
4938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4940 
      return
559 chandransh 4941 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4942 
    if self.success != None:
4943 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4944 
      self.success.write(oprot)
4945 
      oprot.writeFieldEnd()
559 chandransh 4946 
    if self.ucex != None:
4947 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4948 
      self.ucex.write(oprot)
94 ashish 4949 
      oprot.writeFieldEnd()
4950 
    oprot.writeFieldStop()
4951 
    oprot.writeStructEnd()
4952 
 
4953 
  def __repr__(self):
4954 
    L = ['%s=%r' % (key, value)
4955 
      for key, value in self.__dict__.iteritems()]
4956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4957 
 
4958 
  def __eq__(self, other):
4959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4960 
 
4961 
  def __ne__(self, other):
4962 
    return not (self == other)
4963 
 
559 chandransh 4964 
class authenticateUser_args:
94 ashish 4965 
  """
4966 
  Attributes:
4967 
   - email
4968 
   - password
4969 
  """
4970 
 
4971 
  thrift_spec = (
4972 
    None, # 0
4973 
    (1, TType.STRING, 'email', None, None, ), # 1
4974 
    (2, TType.STRING, 'password', None, None, ), # 2
4975 
  )
4976 
 
4977 
  def __init__(self, email=None, password=None,):
4978 
    self.email = email
4979 
    self.password = password
4980 
 
4981 
  def read(self, iprot):
4982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4984 
      return
4985 
    iprot.readStructBegin()
4986 
    while True:
4987 
      (fname, ftype, fid) = iprot.readFieldBegin()
4988 
      if ftype == TType.STOP:
4989 
        break
4990 
      if fid == 1:
4991 
        if ftype == TType.STRING:
4992 
          self.email = iprot.readString();
4993 
        else:
4994 
          iprot.skip(ftype)
4995 
      elif fid == 2:
4996 
        if ftype == TType.STRING:
4997 
          self.password = iprot.readString();
4998 
        else:
4999 
          iprot.skip(ftype)
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
559 chandransh 5009 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 5010 
    if self.email != None:
5011 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5012 
      oprot.writeString(self.email)
5013 
      oprot.writeFieldEnd()
5014 
    if self.password != None:
5015 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5016 
      oprot.writeString(self.password)
5017 
      oprot.writeFieldEnd()
5018 
    oprot.writeFieldStop()
5019 
    oprot.writeStructEnd()
5020 
 
5021 
  def __repr__(self):
5022 
    L = ['%s=%r' % (key, value)
5023 
      for key, value in self.__dict__.iteritems()]
5024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5025 
 
5026 
  def __eq__(self, other):
5027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5028 
 
5029 
  def __ne__(self, other):
5030 
    return not (self == other)
5031 
 
559 chandransh 5032 
class authenticateUser_result:
94 ashish 5033 
  """
5034 
  Attributes:
5035 
   - success
559 chandransh 5036 
   - auex
94 ashish 5037 
  """
5038 
 
5039 
  thrift_spec = (
559 chandransh 5040 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5041 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5042 
  )
5043 
 
559 chandransh 5044 
  def __init__(self, success=None, auex=None,):
94 ashish 5045 
    self.success = success
559 chandransh 5046 
    self.auex = auex
94 ashish 5047 
 
5048 
  def read(self, iprot):
5049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5051 
      return
5052 
    iprot.readStructBegin()
5053 
    while True:
5054 
      (fname, ftype, fid) = iprot.readFieldBegin()
5055 
      if ftype == TType.STOP:
5056 
        break
5057 
      if fid == 0:
5058 
        if ftype == TType.STRUCT:
559 chandransh 5059 
          self.success = User()
94 ashish 5060 
          self.success.read(iprot)
5061 
        else:
5062 
          iprot.skip(ftype)
5063 
      elif fid == 1:
5064 
        if ftype == TType.STRUCT:
559 chandransh 5065 
          self.auex = AuthenticationException()
5066 
          self.auex.read(iprot)
94 ashish 5067 
        else:
5068 
          iprot.skip(ftype)
5069 
      else:
5070 
        iprot.skip(ftype)
5071 
      iprot.readFieldEnd()
5072 
    iprot.readStructEnd()
5073 
 
5074 
  def write(self, oprot):
5075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5077 
      return
559 chandransh 5078 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 5079 
    if self.success != None:
5080 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5081 
      self.success.write(oprot)
5082 
      oprot.writeFieldEnd()
559 chandransh 5083 
    if self.auex != None:
5084 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5085 
      self.auex.write(oprot)
94 ashish 5086 
      oprot.writeFieldEnd()
5087 
    oprot.writeFieldStop()
5088 
    oprot.writeStructEnd()
5089 
 
5090 
  def __repr__(self):
5091 
    L = ['%s=%r' % (key, value)
5092 
      for key, value in self.__dict__.iteritems()]
5093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5094 
 
5095 
  def __eq__(self, other):
5096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5097 
 
5098 
  def __ne__(self, other):
5099 
    return not (self == other)
5100 
 
559 chandransh 5101 
class userExists_args:
122 ashish 5102 
  """
5103 
  Attributes:
559 chandransh 5104 
   - email
122 ashish 5105 
  """
5106 
 
5107 
  thrift_spec = (
5108 
    None, # 0
559 chandransh 5109 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5110 
  )
5111 
 
559 chandransh 5112 
  def __init__(self, email=None,):
5113 
    self.email = email
122 ashish 5114 
 
5115 
  def read(self, iprot):
5116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5118 
      return
5119 
    iprot.readStructBegin()
5120 
    while True:
5121 
      (fname, ftype, fid) = iprot.readFieldBegin()
5122 
      if ftype == TType.STOP:
5123 
        break
5124 
      if fid == 1:
5125 
        if ftype == TType.STRING:
559 chandransh 5126 
          self.email = iprot.readString();
122 ashish 5127 
        else:
5128 
          iprot.skip(ftype)
559 chandransh 5129 
      else:
5130 
        iprot.skip(ftype)
5131 
      iprot.readFieldEnd()
5132 
    iprot.readStructEnd()
5133 
 
5134 
  def write(self, oprot):
5135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5137 
      return
5138 
    oprot.writeStructBegin('userExists_args')
5139 
    if self.email != None:
5140 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5141 
      oprot.writeString(self.email)
5142 
      oprot.writeFieldEnd()
5143 
    oprot.writeFieldStop()
5144 
    oprot.writeStructEnd()
5145 
 
5146 
  def __repr__(self):
5147 
    L = ['%s=%r' % (key, value)
5148 
      for key, value in self.__dict__.iteritems()]
5149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5150 
 
5151 
  def __eq__(self, other):
5152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5153 
 
5154 
  def __ne__(self, other):
5155 
    return not (self == other)
5156 
 
5157 
class userExists_result:
5158 
  """
5159 
  Attributes:
5160 
   - success
5161 
   - ucx
5162 
  """
5163 
 
5164 
  thrift_spec = (
5165 
    (0, TType.BOOL, 'success', None, None, ), # 0
5166 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5167 
  )
5168 
 
5169 
  def __init__(self, success=None, ucx=None,):
5170 
    self.success = success
5171 
    self.ucx = ucx
5172 
 
5173 
  def read(self, iprot):
5174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5176 
      return
5177 
    iprot.readStructBegin()
5178 
    while True:
5179 
      (fname, ftype, fid) = iprot.readFieldBegin()
5180 
      if ftype == TType.STOP:
5181 
        break
5182 
      if fid == 0:
5183 
        if ftype == TType.BOOL:
5184 
          self.success = iprot.readBool();
5185 
        else:
5186 
          iprot.skip(ftype)
5187 
      elif fid == 1:
5188 
        if ftype == TType.STRUCT:
5189 
          self.ucx = UserContextException()
5190 
          self.ucx.read(iprot)
5191 
        else:
5192 
          iprot.skip(ftype)
5193 
      else:
5194 
        iprot.skip(ftype)
5195 
      iprot.readFieldEnd()
5196 
    iprot.readStructEnd()
5197 
 
5198 
  def write(self, oprot):
5199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5201 
      return
5202 
    oprot.writeStructBegin('userExists_result')
5203 
    if self.success != None:
5204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5205 
      oprot.writeBool(self.success)
5206 
      oprot.writeFieldEnd()
5207 
    if self.ucx != None:
5208 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5209 
      self.ucx.write(oprot)
5210 
      oprot.writeFieldEnd()
5211 
    oprot.writeFieldStop()
5212 
    oprot.writeStructEnd()
5213 
 
5214 
  def __repr__(self):
5215 
    L = ['%s=%r' % (key, value)
5216 
      for key, value in self.__dict__.iteritems()]
5217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5218 
 
5219 
  def __eq__(self, other):
5220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5221 
 
5222 
  def __ne__(self, other):
5223 
    return not (self == other)
5224 
 
5225 
class addAddressForUser_args:
5226 
  """
5227 
  Attributes:
5228 
   - userId
5229 
   - address
5230 
   - setDefault
5231 
  """
5232 
 
5233 
  thrift_spec = (
5234 
    None, # 0
5235 
    (1, TType.I64, 'userId', None, None, ), # 1
5236 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5237 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5238 
  )
5239 
 
567 rajveer 5240 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5241 
    self.userId = userId
5242 
    self.address = address
5243 
    self.setDefault = setDefault
5244 
 
5245 
  def read(self, iprot):
5246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5248 
      return
5249 
    iprot.readStructBegin()
5250 
    while True:
5251 
      (fname, ftype, fid) = iprot.readFieldBegin()
5252 
      if ftype == TType.STOP:
5253 
        break
5254 
      if fid == 1:
5255 
        if ftype == TType.I64:
5256 
          self.userId = iprot.readI64();
5257 
        else:
5258 
          iprot.skip(ftype)
122 ashish 5259 
      elif fid == 2:
559 chandransh 5260 
        if ftype == TType.STRUCT:
5261 
          self.address = Address()
5262 
          self.address.read(iprot)
122 ashish 5263 
        else:
5264 
          iprot.skip(ftype)
5265 
      elif fid == 3:
5266 
        if ftype == TType.BOOL:
559 chandransh 5267 
          self.setDefault = iprot.readBool();
122 ashish 5268 
        else:
5269 
          iprot.skip(ftype)
5270 
      else:
5271 
        iprot.skip(ftype)
5272 
      iprot.readFieldEnd()
5273 
    iprot.readStructEnd()
5274 
 
5275 
  def write(self, oprot):
5276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5278 
      return
559 chandransh 5279 
    oprot.writeStructBegin('addAddressForUser_args')
5280 
    if self.userId != None:
5281 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5282 
      oprot.writeI64(self.userId)
122 ashish 5283 
      oprot.writeFieldEnd()
559 chandransh 5284 
    if self.address != None:
5285 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5286 
      self.address.write(oprot)
122 ashish 5287 
      oprot.writeFieldEnd()
559 chandransh 5288 
    if self.setDefault != None:
567 rajveer 5289 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5290 
      oprot.writeBool(self.setDefault)
5291 
      oprot.writeFieldEnd()
122 ashish 5292 
    oprot.writeFieldStop()
5293 
    oprot.writeStructEnd()
5294 
 
5295 
  def __repr__(self):
5296 
    L = ['%s=%r' % (key, value)
5297 
      for key, value in self.__dict__.iteritems()]
5298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5299 
 
5300 
  def __eq__(self, other):
5301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5302 
 
5303 
  def __ne__(self, other):
5304 
    return not (self == other)
5305 
 
559 chandransh 5306 
class addAddressForUser_result:
122 ashish 5307 
  """
5308 
  Attributes:
5309 
   - success
559 chandransh 5310 
   - ucx
122 ashish 5311 
  """
5312 
 
5313 
  thrift_spec = (
567 rajveer 5314 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5315 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5316 
  )
5317 
 
559 chandransh 5318 
  def __init__(self, success=None, ucx=None,):
122 ashish 5319 
    self.success = success
559 chandransh 5320 
    self.ucx = ucx
122 ashish 5321 
 
5322 
  def read(self, iprot):
5323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5325 
      return
5326 
    iprot.readStructBegin()
5327 
    while True:
5328 
      (fname, ftype, fid) = iprot.readFieldBegin()
5329 
      if ftype == TType.STOP:
5330 
        break
5331 
      if fid == 0:
567 rajveer 5332 
        if ftype == TType.I64:
5333 
          self.success = iprot.readI64();
122 ashish 5334 
        else:
5335 
          iprot.skip(ftype)
5336 
      elif fid == 1:
5337 
        if ftype == TType.STRUCT:
559 chandransh 5338 
          self.ucx = UserContextException()
5339 
          self.ucx.read(iprot)
122 ashish 5340 
        else:
5341 
          iprot.skip(ftype)
5342 
      else:
5343 
        iprot.skip(ftype)
5344 
      iprot.readFieldEnd()
5345 
    iprot.readStructEnd()
5346 
 
5347 
  def write(self, oprot):
5348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5350 
      return
559 chandransh 5351 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5352 
    if self.success != None:
567 rajveer 5353 
      oprot.writeFieldBegin('success', TType.I64, 0)
5354 
      oprot.writeI64(self.success)
122 ashish 5355 
      oprot.writeFieldEnd()
559 chandransh 5356 
    if self.ucx != None:
5357 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5358 
      self.ucx.write(oprot)
122 ashish 5359 
      oprot.writeFieldEnd()
5360 
    oprot.writeFieldStop()
5361 
    oprot.writeStructEnd()
5362 
 
5363 
  def __repr__(self):
5364 
    L = ['%s=%r' % (key, value)
5365 
      for key, value in self.__dict__.iteritems()]
5366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5367 
 
5368 
  def __eq__(self, other):
5369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5370 
 
5371 
  def __ne__(self, other):
5372 
    return not (self == other)
5373 
 
559 chandransh 5374 
class removeAddressForUser_args:
94 ashish 5375 
  """
5376 
  Attributes:
559 chandransh 5377 
   - userid
5378 
   - addressId
94 ashish 5379 
  """
5380 
 
5381 
  thrift_spec = (
5382 
    None, # 0
559 chandransh 5383 
    (1, TType.I64, 'userid', None, None, ), # 1
5384 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5385 
  )
5386 
 
559 chandransh 5387 
  def __init__(self, userid=None, addressId=None,):
5388 
    self.userid = userid
5389 
    self.addressId = addressId
94 ashish 5390 
 
5391 
  def read(self, iprot):
5392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5394 
      return
5395 
    iprot.readStructBegin()
5396 
    while True:
5397 
      (fname, ftype, fid) = iprot.readFieldBegin()
5398 
      if ftype == TType.STOP:
5399 
        break
5400 
      if fid == 1:
559 chandransh 5401 
        if ftype == TType.I64:
5402 
          self.userid = iprot.readI64();
94 ashish 5403 
        else:
5404 
          iprot.skip(ftype)
559 chandransh 5405 
      elif fid == 2:
5406 
        if ftype == TType.I64:
5407 
          self.addressId = iprot.readI64();
5408 
        else:
5409 
          iprot.skip(ftype)
94 ashish 5410 
      else:
5411 
        iprot.skip(ftype)
5412 
      iprot.readFieldEnd()
5413 
    iprot.readStructEnd()
5414 
 
5415 
  def write(self, oprot):
5416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5418 
      return
559 chandransh 5419 
    oprot.writeStructBegin('removeAddressForUser_args')
5420 
    if self.userid != None:
5421 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5422 
      oprot.writeI64(self.userid)
94 ashish 5423 
      oprot.writeFieldEnd()
559 chandransh 5424 
    if self.addressId != None:
5425 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5426 
      oprot.writeI64(self.addressId)
5427 
      oprot.writeFieldEnd()
94 ashish 5428 
    oprot.writeFieldStop()
5429 
    oprot.writeStructEnd()
5430 
 
5431 
  def __repr__(self):
5432 
    L = ['%s=%r' % (key, value)
5433 
      for key, value in self.__dict__.iteritems()]
5434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5435 
 
5436 
  def __eq__(self, other):
5437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5438 
 
5439 
  def __ne__(self, other):
5440 
    return not (self == other)
5441 
 
559 chandransh 5442 
class removeAddressForUser_result:
94 ashish 5443 
  """
5444 
  Attributes:
5445 
   - success
5446 
   - ucx
5447 
  """
5448 
 
5449 
  thrift_spec = (
5450 
    (0, TType.BOOL, 'success', None, None, ), # 0
5451 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5452 
  )
5453 
 
5454 
  def __init__(self, success=None, ucx=None,):
5455 
    self.success = success
5456 
    self.ucx = ucx
5457 
 
5458 
  def read(self, iprot):
5459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5461 
      return
5462 
    iprot.readStructBegin()
5463 
    while True:
5464 
      (fname, ftype, fid) = iprot.readFieldBegin()
5465 
      if ftype == TType.STOP:
5466 
        break
5467 
      if fid == 0:
5468 
        if ftype == TType.BOOL:
5469 
          self.success = iprot.readBool();
5470 
        else:
5471 
          iprot.skip(ftype)
5472 
      elif fid == 1:
5473 
        if ftype == TType.STRUCT:
5474 
          self.ucx = UserContextException()
5475 
          self.ucx.read(iprot)
5476 
        else:
5477 
          iprot.skip(ftype)
5478 
      else:
5479 
        iprot.skip(ftype)
5480 
      iprot.readFieldEnd()
5481 
    iprot.readStructEnd()
5482 
 
5483 
  def write(self, oprot):
5484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5486 
      return
559 chandransh 5487 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5488 
    if self.success != None:
5489 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5490 
      oprot.writeBool(self.success)
5491 
      oprot.writeFieldEnd()
5492 
    if self.ucx != None:
5493 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5494 
      self.ucx.write(oprot)
5495 
      oprot.writeFieldEnd()
5496 
    oprot.writeFieldStop()
5497 
    oprot.writeStructEnd()
5498 
 
5499 
  def __repr__(self):
5500 
    L = ['%s=%r' % (key, value)
5501 
      for key, value in self.__dict__.iteritems()]
5502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5503 
 
5504 
  def __eq__(self, other):
5505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5506 
 
5507 
  def __ne__(self, other):
5508 
    return not (self == other)
5509 
 
559 chandransh 5510 
class setUserAsLoggedIn_args:
94 ashish 5511 
  """
5512 
  Attributes:
559 chandransh 5513 
   - userId
94 ashish 5514 
   - timestamp
5515 
  """
5516 
 
5517 
  thrift_spec = (
5518 
    None, # 0
559 chandransh 5519 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5520 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5521 
  )
5522 
 
559 chandransh 5523 
  def __init__(self, userId=None, timestamp=None,):
5524 
    self.userId = userId
94 ashish 5525 
    self.timestamp = timestamp
5526 
 
5527 
  def read(self, iprot):
5528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5530 
      return
5531 
    iprot.readStructBegin()
5532 
    while True:
5533 
      (fname, ftype, fid) = iprot.readFieldBegin()
5534 
      if ftype == TType.STOP:
5535 
        break
5536 
      if fid == 1:
559 chandransh 5537 
        if ftype == TType.I64:
5538 
          self.userId = iprot.readI64();
94 ashish 5539 
        else:
5540 
          iprot.skip(ftype)
5541 
      elif fid == 2:
5542 
        if ftype == TType.I64:
5543 
          self.timestamp = iprot.readI64();
5544 
        else:
5545 
          iprot.skip(ftype)
5546 
      else:
5547 
        iprot.skip(ftype)
5548 
      iprot.readFieldEnd()
5549 
    iprot.readStructEnd()
5550 
 
5551 
  def write(self, oprot):
5552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5554 
      return
559 chandransh 5555 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5556 
    if self.userId != None:
5557 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5558 
      oprot.writeI64(self.userId)
94 ashish 5559 
      oprot.writeFieldEnd()
5560 
    if self.timestamp != None:
5561 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5562 
      oprot.writeI64(self.timestamp)
5563 
      oprot.writeFieldEnd()
5564 
    oprot.writeFieldStop()
5565 
    oprot.writeStructEnd()
5566 
 
5567 
  def __repr__(self):
5568 
    L = ['%s=%r' % (key, value)
5569 
      for key, value in self.__dict__.iteritems()]
5570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5571 
 
5572 
  def __eq__(self, other):
5573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5574 
 
5575 
  def __ne__(self, other):
5576 
    return not (self == other)
5577 
 
559 chandransh 5578 
class setUserAsLoggedIn_result:
94 ashish 5579 
  """
5580 
  Attributes:
5581 
   - success
5582 
   - ucx
5583 
  """
5584 
 
5585 
  thrift_spec = (
5586 
    (0, TType.BOOL, 'success', None, None, ), # 0
5587 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5588 
  )
5589 
 
5590 
  def __init__(self, success=None, ucx=None,):
5591 
    self.success = success
5592 
    self.ucx = ucx
5593 
 
5594 
  def read(self, iprot):
5595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5597 
      return
5598 
    iprot.readStructBegin()
5599 
    while True:
5600 
      (fname, ftype, fid) = iprot.readFieldBegin()
5601 
      if ftype == TType.STOP:
5602 
        break
5603 
      if fid == 0:
5604 
        if ftype == TType.BOOL:
5605 
          self.success = iprot.readBool();
5606 
        else:
5607 
          iprot.skip(ftype)
5608 
      elif fid == 1:
5609 
        if ftype == TType.STRUCT:
5610 
          self.ucx = UserContextException()
5611 
          self.ucx.read(iprot)
5612 
        else:
5613 
          iprot.skip(ftype)
5614 
      else:
5615 
        iprot.skip(ftype)
5616 
      iprot.readFieldEnd()
5617 
    iprot.readStructEnd()
5618 
 
5619 
  def write(self, oprot):
5620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5622 
      return
559 chandransh 5623 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5624 
    if self.success != None:
5625 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5626 
      oprot.writeBool(self.success)
5627 
      oprot.writeFieldEnd()
5628 
    if self.ucx != None:
5629 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5630 
      self.ucx.write(oprot)
5631 
      oprot.writeFieldEnd()
5632 
    oprot.writeFieldStop()
5633 
    oprot.writeStructEnd()
5634 
 
5635 
  def __repr__(self):
5636 
    L = ['%s=%r' % (key, value)
5637 
      for key, value in self.__dict__.iteritems()]
5638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5639 
 
5640 
  def __eq__(self, other):
5641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5642 
 
5643 
  def __ne__(self, other):
5644 
    return not (self == other)
5645 
 
559 chandransh 5646 
class setUserAsLoggedOut_args:
94 ashish 5647 
  """
5648 
  Attributes:
5649 
   - userid
5650 
   - timestamp
5651 
  """
5652 
 
5653 
  thrift_spec = (
5654 
    None, # 0
559 chandransh 5655 
    (1, TType.I64, 'userid', None, None, ), # 1
5656 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5657 
  )
5658 
 
559 chandransh 5659 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5660 
    self.userid = userid
5661 
    self.timestamp = timestamp
5662 
 
5663 
  def read(self, iprot):
5664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5666 
      return
5667 
    iprot.readStructBegin()
5668 
    while True:
5669 
      (fname, ftype, fid) = iprot.readFieldBegin()
5670 
      if ftype == TType.STOP:
5671 
        break
5672 
      if fid == 1:
5673 
        if ftype == TType.I64:
5674 
          self.userid = iprot.readI64();
5675 
        else:
5676 
          iprot.skip(ftype)
559 chandransh 5677 
      elif fid == 2:
94 ashish 5678 
        if ftype == TType.I64:
5679 
          self.timestamp = iprot.readI64();
5680 
        else:
5681 
          iprot.skip(ftype)
5682 
      else:
5683 
        iprot.skip(ftype)
5684 
      iprot.readFieldEnd()
5685 
    iprot.readStructEnd()
5686 
 
5687 
  def write(self, oprot):
5688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5690 
      return
559 chandransh 5691 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5692 
    if self.userid != None:
559 chandransh 5693 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5694 
      oprot.writeI64(self.userid)
5695 
      oprot.writeFieldEnd()
5696 
    if self.timestamp != None:
559 chandransh 5697 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5698 
      oprot.writeI64(self.timestamp)
5699 
      oprot.writeFieldEnd()
5700 
    oprot.writeFieldStop()
5701 
    oprot.writeStructEnd()
5702 
 
5703 
  def __repr__(self):
5704 
    L = ['%s=%r' % (key, value)
5705 
      for key, value in self.__dict__.iteritems()]
5706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5707 
 
5708 
  def __eq__(self, other):
5709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5710 
 
5711 
  def __ne__(self, other):
5712 
    return not (self == other)
5713 
 
559 chandransh 5714 
class setUserAsLoggedOut_result:
94 ashish 5715 
  """
5716 
  Attributes:
5717 
   - success
5718 
   - ucx
5719 
  """
5720 
 
5721 
  thrift_spec = (
5722 
    (0, TType.BOOL, 'success', None, None, ), # 0
5723 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5724 
  )
5725 
 
5726 
  def __init__(self, success=None, ucx=None,):
5727 
    self.success = success
5728 
    self.ucx = ucx
5729 
 
5730 
  def read(self, iprot):
5731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5733 
      return
5734 
    iprot.readStructBegin()
5735 
    while True:
5736 
      (fname, ftype, fid) = iprot.readFieldBegin()
5737 
      if ftype == TType.STOP:
5738 
        break
5739 
      if fid == 0:
5740 
        if ftype == TType.BOOL:
5741 
          self.success = iprot.readBool();
5742 
        else:
5743 
          iprot.skip(ftype)
5744 
      elif fid == 1:
5745 
        if ftype == TType.STRUCT:
5746 
          self.ucx = UserContextException()
5747 
          self.ucx.read(iprot)
5748 
        else:
5749 
          iprot.skip(ftype)
5750 
      else:
5751 
        iprot.skip(ftype)
5752 
      iprot.readFieldEnd()
5753 
    iprot.readStructEnd()
5754 
 
5755 
  def write(self, oprot):
5756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5758 
      return
559 chandransh 5759 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5760 
    if self.success != None:
5761 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5762 
      oprot.writeBool(self.success)
5763 
      oprot.writeFieldEnd()
5764 
    if self.ucx != None:
5765 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5766 
      self.ucx.write(oprot)
5767 
      oprot.writeFieldEnd()
5768 
    oprot.writeFieldStop()
5769 
    oprot.writeStructEnd()
5770 
 
5771 
  def __repr__(self):
5772 
    L = ['%s=%r' % (key, value)
5773 
      for key, value in self.__dict__.iteritems()]
5774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5775 
 
5776 
  def __eq__(self, other):
5777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5778 
 
5779 
  def __ne__(self, other):
5780 
    return not (self == other)
5781 
 
559 chandransh 5782 
class setDefaultAddress_args:
94 ashish 5783 
  """
5784 
  Attributes:
5785 
   - userid
5786 
   - addressId
5787 
  """
5788 
 
5789 
  thrift_spec = (
5790 
    None, # 0
5791 
    (1, TType.I64, 'userid', None, None, ), # 1
5792 
    (2, TType.I64, 'addressId', None, None, ), # 2
5793 
  )
5794 
 
5795 
  def __init__(self, userid=None, addressId=None,):
5796 
    self.userid = userid
5797 
    self.addressId = addressId
5798 
 
5799 
  def read(self, iprot):
5800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5802 
      return
5803 
    iprot.readStructBegin()
5804 
    while True:
5805 
      (fname, ftype, fid) = iprot.readFieldBegin()
5806 
      if ftype == TType.STOP:
5807 
        break
5808 
      if fid == 1:
5809 
        if ftype == TType.I64:
5810 
          self.userid = iprot.readI64();
5811 
        else:
5812 
          iprot.skip(ftype)
5813 
      elif fid == 2:
5814 
        if ftype == TType.I64:
5815 
          self.addressId = iprot.readI64();
5816 
        else:
5817 
          iprot.skip(ftype)
5818 
      else:
5819 
        iprot.skip(ftype)
5820 
      iprot.readFieldEnd()
5821 
    iprot.readStructEnd()
5822 
 
5823 
  def write(self, oprot):
5824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5826 
      return
559 chandransh 5827 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5828 
    if self.userid != None:
5829 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5830 
      oprot.writeI64(self.userid)
5831 
      oprot.writeFieldEnd()
5832 
    if self.addressId != None:
5833 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5834 
      oprot.writeI64(self.addressId)
5835 
      oprot.writeFieldEnd()
5836 
    oprot.writeFieldStop()
5837 
    oprot.writeStructEnd()
5838 
 
5839 
  def __repr__(self):
5840 
    L = ['%s=%r' % (key, value)
5841 
      for key, value in self.__dict__.iteritems()]
5842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5843 
 
5844 
  def __eq__(self, other):
5845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5846 
 
5847 
  def __ne__(self, other):
5848 
    return not (self == other)
5849 
 
559 chandransh 5850 
class setDefaultAddress_result:
94 ashish 5851 
  """
5852 
  Attributes:
5853 
   - success
5854 
   - ucx
5855 
  """
5856 
 
5857 
  thrift_spec = (
5858 
    (0, TType.BOOL, 'success', None, None, ), # 0
5859 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5860 
  )
5861 
 
5862 
  def __init__(self, success=None, ucx=None,):
5863 
    self.success = success
5864 
    self.ucx = ucx
5865 
 
5866 
  def read(self, iprot):
5867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5869 
      return
5870 
    iprot.readStructBegin()
5871 
    while True:
5872 
      (fname, ftype, fid) = iprot.readFieldBegin()
5873 
      if ftype == TType.STOP:
5874 
        break
5875 
      if fid == 0:
5876 
        if ftype == TType.BOOL:
5877 
          self.success = iprot.readBool();
5878 
        else:
5879 
          iprot.skip(ftype)
5880 
      elif fid == 1:
5881 
        if ftype == TType.STRUCT:
5882 
          self.ucx = UserContextException()
5883 
          self.ucx.read(iprot)
5884 
        else:
5885 
          iprot.skip(ftype)
5886 
      else:
5887 
        iprot.skip(ftype)
5888 
      iprot.readFieldEnd()
5889 
    iprot.readStructEnd()
5890 
 
5891 
  def write(self, oprot):
5892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5894 
      return
559 chandransh 5895 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5896 
    if self.success != None:
5897 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5898 
      oprot.writeBool(self.success)
5899 
      oprot.writeFieldEnd()
5900 
    if self.ucx != None:
5901 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5902 
      self.ucx.write(oprot)
5903 
      oprot.writeFieldEnd()
5904 
    oprot.writeFieldStop()
5905 
    oprot.writeStructEnd()
5906 
 
5907 
  def __repr__(self):
5908 
    L = ['%s=%r' % (key, value)
5909 
      for key, value in self.__dict__.iteritems()]
5910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5911 
 
5912 
  def __eq__(self, other):
5913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5914 
 
5915 
  def __ne__(self, other):
5916 
    return not (self == other)
5917 
 
559 chandransh 5918 
class updatePassword_args:
94 ashish 5919 
  """
5920 
  Attributes:
559 chandransh 5921 
   - userid
594 rajveer 5922 
   - oldPassword
5923 
   - newPassword
94 ashish 5924 
  """
5925 
 
5926 
  thrift_spec = (
5927 
    None, # 0
559 chandransh 5928 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5929 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5930 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5931 
  )
5932 
 
594 rajveer 5933 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5934 
    self.userid = userid
594 rajveer 5935 
    self.oldPassword = oldPassword
5936 
    self.newPassword = newPassword
94 ashish 5937 
 
5938 
  def read(self, iprot):
5939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5941 
      return
5942 
    iprot.readStructBegin()
5943 
    while True:
5944 
      (fname, ftype, fid) = iprot.readFieldBegin()
5945 
      if ftype == TType.STOP:
5946 
        break
5947 
      if fid == 1:
5948 
        if ftype == TType.I64:
559 chandransh 5949 
          self.userid = iprot.readI64();
94 ashish 5950 
        else:
5951 
          iprot.skip(ftype)
5952 
      elif fid == 2:
559 chandransh 5953 
        if ftype == TType.STRING:
594 rajveer 5954 
          self.oldPassword = iprot.readString();
94 ashish 5955 
        else:
5956 
          iprot.skip(ftype)
594 rajveer 5957 
      elif fid == 3:
5958 
        if ftype == TType.STRING:
5959 
          self.newPassword = iprot.readString();
5960 
        else:
5961 
          iprot.skip(ftype)
94 ashish 5962 
      else:
5963 
        iprot.skip(ftype)
5964 
      iprot.readFieldEnd()
5965 
    iprot.readStructEnd()
5966 
 
5967 
  def write(self, oprot):
5968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5970 
      return
559 chandransh 5971 
    oprot.writeStructBegin('updatePassword_args')
5972 
    if self.userid != None:
5973 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5974 
      oprot.writeI64(self.userid)
94 ashish 5975 
      oprot.writeFieldEnd()
594 rajveer 5976 
    if self.oldPassword != None:
5977 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5978 
      oprot.writeString(self.oldPassword)
94 ashish 5979 
      oprot.writeFieldEnd()
594 rajveer 5980 
    if self.newPassword != None:
5981 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5982 
      oprot.writeString(self.newPassword)
5983 
      oprot.writeFieldEnd()
94 ashish 5984 
    oprot.writeFieldStop()
5985 
    oprot.writeStructEnd()
5986 
 
5987 
  def __repr__(self):
5988 
    L = ['%s=%r' % (key, value)
5989 
      for key, value in self.__dict__.iteritems()]
5990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5991 
 
5992 
  def __eq__(self, other):
5993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5994 
 
5995 
  def __ne__(self, other):
5996 
    return not (self == other)
5997 
 
559 chandransh 5998 
class updatePassword_result:
94 ashish 5999 
  """
6000 
  Attributes:
6001 
   - success
6002 
   - ucx
6003 
  """
6004 
 
6005 
  thrift_spec = (
6006 
    (0, TType.BOOL, 'success', None, None, ), # 0
6007 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6008 
  )
6009 
 
6010 
  def __init__(self, success=None, ucx=None,):
6011 
    self.success = success
6012 
    self.ucx = ucx
6013 
 
6014 
  def read(self, iprot):
6015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6017 
      return
6018 
    iprot.readStructBegin()
6019 
    while True:
6020 
      (fname, ftype, fid) = iprot.readFieldBegin()
6021 
      if ftype == TType.STOP:
6022 
        break
6023 
      if fid == 0:
6024 
        if ftype == TType.BOOL:
6025 
          self.success = iprot.readBool();
6026 
        else:
6027 
          iprot.skip(ftype)
6028 
      elif fid == 1:
6029 
        if ftype == TType.STRUCT:
6030 
          self.ucx = UserContextException()
6031 
          self.ucx.read(iprot)
6032 
        else:
6033 
          iprot.skip(ftype)
6034 
      else:
6035 
        iprot.skip(ftype)
6036 
      iprot.readFieldEnd()
6037 
    iprot.readStructEnd()
6038 
 
6039 
  def write(self, oprot):
6040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6042 
      return
559 chandransh 6043 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 6044 
    if self.success != None:
6045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6046 
      oprot.writeBool(self.success)
6047 
      oprot.writeFieldEnd()
6048 
    if self.ucx != None:
6049 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6050 
      self.ucx.write(oprot)
6051 
      oprot.writeFieldEnd()
6052 
    oprot.writeFieldStop()
6053 
    oprot.writeStructEnd()
6054 
 
6055 
  def __repr__(self):
6056 
    L = ['%s=%r' % (key, value)
6057 
      for key, value in self.__dict__.iteritems()]
6058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6059 
 
6060 
  def __eq__(self, other):
6061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6062 
 
6063 
  def __ne__(self, other):
6064 
    return not (self == other)
6065 
 
581 rajveer 6066 
class forgotPassword_args:
6067 
  """
6068 
  Attributes:
6069 
   - email
884 rajveer 6070 
   - newPassword
581 rajveer 6071 
  """
6072 
 
6073 
  thrift_spec = (
6074 
    None, # 0
6075 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6076 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6077 
  )
6078 
 
884 rajveer 6079 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6080 
    self.email = email
884 rajveer 6081 
    self.newPassword = newPassword
581 rajveer 6082 
 
6083 
  def read(self, iprot):
6084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6086 
      return
6087 
    iprot.readStructBegin()
6088 
    while True:
6089 
      (fname, ftype, fid) = iprot.readFieldBegin()
6090 
      if ftype == TType.STOP:
6091 
        break
6092 
      if fid == 1:
6093 
        if ftype == TType.STRING:
6094 
          self.email = iprot.readString();
6095 
        else:
6096 
          iprot.skip(ftype)
884 rajveer 6097 
      elif fid == 2:
6098 
        if ftype == TType.STRING:
6099 
          self.newPassword = iprot.readString();
6100 
        else:
6101 
          iprot.skip(ftype)
581 rajveer 6102 
      else:
6103 
        iprot.skip(ftype)
6104 
      iprot.readFieldEnd()
6105 
    iprot.readStructEnd()
6106 
 
6107 
  def write(self, oprot):
6108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6110 
      return
6111 
    oprot.writeStructBegin('forgotPassword_args')
6112 
    if self.email != None:
6113 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6114 
      oprot.writeString(self.email)
6115 
      oprot.writeFieldEnd()
884 rajveer 6116 
    if self.newPassword != None:
6117 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6118 
      oprot.writeString(self.newPassword)
6119 
      oprot.writeFieldEnd()
581 rajveer 6120 
    oprot.writeFieldStop()
6121 
    oprot.writeStructEnd()
6122 
 
6123 
  def __repr__(self):
6124 
    L = ['%s=%r' % (key, value)
6125 
      for key, value in self.__dict__.iteritems()]
6126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6127 
 
6128 
  def __eq__(self, other):
6129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6130 
 
6131 
  def __ne__(self, other):
6132 
    return not (self == other)
6133 
 
6134 
class forgotPassword_result:
6135 
  """
6136 
  Attributes:
6137 
   - success
6138 
   - ucx
6139 
  """
6140 
 
6141 
  thrift_spec = (
6142 
    (0, TType.BOOL, 'success', None, None, ), # 0
6143 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6144 
  )
6145 
 
6146 
  def __init__(self, success=None, ucx=None,):
6147 
    self.success = success
6148 
    self.ucx = ucx
6149 
 
6150 
  def read(self, iprot):
6151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6153 
      return
6154 
    iprot.readStructBegin()
6155 
    while True:
6156 
      (fname, ftype, fid) = iprot.readFieldBegin()
6157 
      if ftype == TType.STOP:
6158 
        break
6159 
      if fid == 0:
6160 
        if ftype == TType.BOOL:
6161 
          self.success = iprot.readBool();
6162 
        else:
6163 
          iprot.skip(ftype)
6164 
      elif fid == 1:
6165 
        if ftype == TType.STRUCT:
6166 
          self.ucx = UserContextException()
6167 
          self.ucx.read(iprot)
6168 
        else:
6169 
          iprot.skip(ftype)
6170 
      else:
6171 
        iprot.skip(ftype)
6172 
      iprot.readFieldEnd()
6173 
    iprot.readStructEnd()
6174 
 
6175 
  def write(self, oprot):
6176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6178 
      return
6179 
    oprot.writeStructBegin('forgotPassword_result')
6180 
    if self.success != None:
6181 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6182 
      oprot.writeBool(self.success)
6183 
      oprot.writeFieldEnd()
6184 
    if self.ucx != None:
6185 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6186 
      self.ucx.write(oprot)
6187 
      oprot.writeFieldEnd()
6188 
    oprot.writeFieldStop()
6189 
    oprot.writeStructEnd()
6190 
 
6191 
  def __repr__(self):
6192 
    L = ['%s=%r' % (key, value)
6193 
      for key, value in self.__dict__.iteritems()]
6194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6195 
 
6196 
  def __eq__(self, other):
6197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6198 
 
6199 
  def __ne__(self, other):
6200 
    return not (self == other)
6201 
 
594 rajveer 6202 
class getAllAddressesForUser_args:
6203 
  """
6204 
  Attributes:
6205 
   - userId
6206 
  """
6207 
 
6208 
  thrift_spec = (
6209 
    None, # 0
6210 
    (1, TType.I64, 'userId', None, None, ), # 1
6211 
  )
6212 
 
6213 
  def __init__(self, userId=None,):
6214 
    self.userId = userId
6215 
 
6216 
  def read(self, iprot):
6217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6219 
      return
6220 
    iprot.readStructBegin()
6221 
    while True:
6222 
      (fname, ftype, fid) = iprot.readFieldBegin()
6223 
      if ftype == TType.STOP:
6224 
        break
6225 
      if fid == 1:
6226 
        if ftype == TType.I64:
6227 
          self.userId = iprot.readI64();
6228 
        else:
6229 
          iprot.skip(ftype)
6230 
      else:
6231 
        iprot.skip(ftype)
6232 
      iprot.readFieldEnd()
6233 
    iprot.readStructEnd()
6234 
 
6235 
  def write(self, oprot):
6236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6238 
      return
6239 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6240 
    if self.userId != None:
6241 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6242 
      oprot.writeI64(self.userId)
6243 
      oprot.writeFieldEnd()
6244 
    oprot.writeFieldStop()
6245 
    oprot.writeStructEnd()
6246 
 
6247 
  def __repr__(self):
6248 
    L = ['%s=%r' % (key, value)
6249 
      for key, value in self.__dict__.iteritems()]
6250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6251 
 
6252 
  def __eq__(self, other):
6253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6254 
 
6255 
  def __ne__(self, other):
6256 
    return not (self == other)
6257 
 
6258 
class getAllAddressesForUser_result:
6259 
  """
6260 
  Attributes:
6261 
   - success
6262 
   - ucx
6263 
  """
6264 
 
6265 
  thrift_spec = (
6266 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6267 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6268 
  )
6269 
 
6270 
  def __init__(self, success=None, ucx=None,):
6271 
    self.success = success
6272 
    self.ucx = ucx
6273 
 
6274 
  def read(self, iprot):
6275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6277 
      return
6278 
    iprot.readStructBegin()
6279 
    while True:
6280 
      (fname, ftype, fid) = iprot.readFieldBegin()
6281 
      if ftype == TType.STOP:
6282 
        break
6283 
      if fid == 0:
6284 
        if ftype == TType.LIST:
6285 
          self.success = []
2981 rajveer 6286 
          (_etype31, _size28) = iprot.readListBegin()
6287 
          for _i32 in xrange(_size28):
6288 
            _elem33 = Address()
6289 
            _elem33.read(iprot)
6290 
            self.success.append(_elem33)
594 rajveer 6291 
          iprot.readListEnd()
6292 
        else:
6293 
          iprot.skip(ftype)
6294 
      elif fid == 1:
6295 
        if ftype == TType.STRUCT:
6296 
          self.ucx = UserContextException()
6297 
          self.ucx.read(iprot)
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      else:
6301 
        iprot.skip(ftype)
6302 
      iprot.readFieldEnd()
6303 
    iprot.readStructEnd()
6304 
 
6305 
  def write(self, oprot):
6306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6308 
      return
6309 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6310 
    if self.success != None:
6311 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6312 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 6313 
      for iter34 in self.success:
6314 
        iter34.write(oprot)
594 rajveer 6315 
      oprot.writeListEnd()
6316 
      oprot.writeFieldEnd()
6317 
    if self.ucx != None:
6318 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6319 
      self.ucx.write(oprot)
6320 
      oprot.writeFieldEnd()
6321 
    oprot.writeFieldStop()
6322 
    oprot.writeStructEnd()
6323 
 
6324 
  def __repr__(self):
6325 
    L = ['%s=%r' % (key, value)
6326 
      for key, value in self.__dict__.iteritems()]
6327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6328 
 
6329 
  def __eq__(self, other):
6330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6331 
 
6332 
  def __ne__(self, other):
6333 
    return not (self == other)
6334 
 
1894 vikas 6335 
class getAddressById_args:
6336 
  """
6337 
  Attributes:
6338 
   - addressId
6339 
  """
6340 
 
6341 
  thrift_spec = (
6342 
    None, # 0
6343 
    (1, TType.I64, 'addressId', None, None, ), # 1
6344 
  )
6345 
 
6346 
  def __init__(self, addressId=None,):
6347 
    self.addressId = addressId
6348 
 
6349 
  def read(self, iprot):
6350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6352 
      return
6353 
    iprot.readStructBegin()
6354 
    while True:
6355 
      (fname, ftype, fid) = iprot.readFieldBegin()
6356 
      if ftype == TType.STOP:
6357 
        break
6358 
      if fid == 1:
6359 
        if ftype == TType.I64:
6360 
          self.addressId = iprot.readI64();
6361 
        else:
6362 
          iprot.skip(ftype)
6363 
      else:
6364 
        iprot.skip(ftype)
6365 
      iprot.readFieldEnd()
6366 
    iprot.readStructEnd()
6367 
 
6368 
  def write(self, oprot):
6369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6371 
      return
6372 
    oprot.writeStructBegin('getAddressById_args')
6373 
    if self.addressId != None:
6374 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6375 
      oprot.writeI64(self.addressId)
6376 
      oprot.writeFieldEnd()
6377 
    oprot.writeFieldStop()
6378 
    oprot.writeStructEnd()
6379 
 
6380 
  def __repr__(self):
6381 
    L = ['%s=%r' % (key, value)
6382 
      for key, value in self.__dict__.iteritems()]
6383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6384 
 
6385 
  def __eq__(self, other):
6386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6387 
 
6388 
  def __ne__(self, other):
6389 
    return not (self == other)
6390 
 
6391 
class getAddressById_result:
6392 
  """
6393 
  Attributes:
6394 
   - success
6395 
   - ucx
6396 
  """
6397 
 
6398 
  thrift_spec = (
6399 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6400 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6401 
  )
6402 
 
6403 
  def __init__(self, success=None, ucx=None,):
6404 
    self.success = success
6405 
    self.ucx = ucx
6406 
 
6407 
  def read(self, iprot):
6408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6410 
      return
6411 
    iprot.readStructBegin()
6412 
    while True:
6413 
      (fname, ftype, fid) = iprot.readFieldBegin()
6414 
      if ftype == TType.STOP:
6415 
        break
6416 
      if fid == 0:
6417 
        if ftype == TType.STRUCT:
6418 
          self.success = Address()
6419 
          self.success.read(iprot)
6420 
        else:
6421 
          iprot.skip(ftype)
6422 
      elif fid == 1:
6423 
        if ftype == TType.STRUCT:
6424 
          self.ucx = UserContextException()
6425 
          self.ucx.read(iprot)
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      else:
6429 
        iprot.skip(ftype)
6430 
      iprot.readFieldEnd()
6431 
    iprot.readStructEnd()
6432 
 
6433 
  def write(self, oprot):
6434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6436 
      return
6437 
    oprot.writeStructBegin('getAddressById_result')
6438 
    if self.success != None:
6439 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6440 
      self.success.write(oprot)
6441 
      oprot.writeFieldEnd()
6442 
    if self.ucx != None:
6443 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6444 
      self.ucx.write(oprot)
6445 
      oprot.writeFieldEnd()
6446 
    oprot.writeFieldStop()
6447 
    oprot.writeStructEnd()
6448 
 
6449 
  def __repr__(self):
6450 
    L = ['%s=%r' % (key, value)
6451 
      for key, value in self.__dict__.iteritems()]
6452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6453 
 
6454 
  def __eq__(self, other):
6455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6456 
 
6457 
  def __ne__(self, other):
6458 
    return not (self == other)
6459 
 
594 rajveer 6460 
class getDefaultAddressId_args:
6461 
  """
6462 
  Attributes:
6463 
   - userId
6464 
  """
6465 
 
6466 
  thrift_spec = (
6467 
    None, # 0
6468 
    (1, TType.I64, 'userId', None, None, ), # 1
6469 
  )
6470 
 
6471 
  def __init__(self, userId=None,):
6472 
    self.userId = userId
6473 
 
6474 
  def read(self, iprot):
6475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6477 
      return
6478 
    iprot.readStructBegin()
6479 
    while True:
6480 
      (fname, ftype, fid) = iprot.readFieldBegin()
6481 
      if ftype == TType.STOP:
6482 
        break
6483 
      if fid == 1:
6484 
        if ftype == TType.I64:
6485 
          self.userId = iprot.readI64();
6486 
        else:
6487 
          iprot.skip(ftype)
6488 
      else:
6489 
        iprot.skip(ftype)
6490 
      iprot.readFieldEnd()
6491 
    iprot.readStructEnd()
6492 
 
6493 
  def write(self, oprot):
6494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6496 
      return
6497 
    oprot.writeStructBegin('getDefaultAddressId_args')
6498 
    if self.userId != None:
6499 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6500 
      oprot.writeI64(self.userId)
6501 
      oprot.writeFieldEnd()
6502 
    oprot.writeFieldStop()
6503 
    oprot.writeStructEnd()
6504 
 
6505 
  def __repr__(self):
6506 
    L = ['%s=%r' % (key, value)
6507 
      for key, value in self.__dict__.iteritems()]
6508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6509 
 
6510 
  def __eq__(self, other):
6511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6512 
 
6513 
  def __ne__(self, other):
6514 
    return not (self == other)
6515 
 
6516 
class getDefaultAddressId_result:
6517 
  """
6518 
  Attributes:
6519 
   - success
6520 
   - ucx
6521 
  """
6522 
 
6523 
  thrift_spec = (
6524 
    (0, TType.I64, 'success', None, None, ), # 0
6525 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6526 
  )
6527 
 
6528 
  def __init__(self, success=None, ucx=None,):
6529 
    self.success = success
6530 
    self.ucx = ucx
6531 
 
6532 
  def read(self, iprot):
6533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6535 
      return
6536 
    iprot.readStructBegin()
6537 
    while True:
6538 
      (fname, ftype, fid) = iprot.readFieldBegin()
6539 
      if ftype == TType.STOP:
6540 
        break
6541 
      if fid == 0:
6542 
        if ftype == TType.I64:
6543 
          self.success = iprot.readI64();
6544 
        else:
6545 
          iprot.skip(ftype)
6546 
      elif fid == 1:
6547 
        if ftype == TType.STRUCT:
6548 
          self.ucx = UserContextException()
6549 
          self.ucx.read(iprot)
6550 
        else:
6551 
          iprot.skip(ftype)
6552 
      else:
6553 
        iprot.skip(ftype)
6554 
      iprot.readFieldEnd()
6555 
    iprot.readStructEnd()
6556 
 
6557 
  def write(self, oprot):
6558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6560 
      return
6561 
    oprot.writeStructBegin('getDefaultAddressId_result')
6562 
    if self.success != None:
6563 
      oprot.writeFieldBegin('success', TType.I64, 0)
6564 
      oprot.writeI64(self.success)
6565 
      oprot.writeFieldEnd()
6566 
    if self.ucx != None:
6567 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6568 
      self.ucx.write(oprot)
6569 
      oprot.writeFieldEnd()
6570 
    oprot.writeFieldStop()
6571 
    oprot.writeStructEnd()
6572 
 
6573 
  def __repr__(self):
6574 
    L = ['%s=%r' % (key, value)
6575 
      for key, value in self.__dict__.iteritems()]
6576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6577 
 
6578 
  def __eq__(self, other):
6579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6580 
 
6581 
  def __ne__(self, other):
6582 
    return not (self == other)
6583 
 
785 rajveer 6584 
class getDefaultPincode_args:
6585 
  """
6586 
  Attributes:
6587 
   - userId
6588 
  """
6589 
 
6590 
  thrift_spec = (
6591 
    None, # 0
6592 
    (1, TType.I64, 'userId', None, None, ), # 1
6593 
  )
6594 
 
6595 
  def __init__(self, userId=None,):
6596 
    self.userId = userId
6597 
 
6598 
  def read(self, iprot):
6599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6601 
      return
6602 
    iprot.readStructBegin()
6603 
    while True:
6604 
      (fname, ftype, fid) = iprot.readFieldBegin()
6605 
      if ftype == TType.STOP:
6606 
        break
6607 
      if fid == 1:
6608 
        if ftype == TType.I64:
6609 
          self.userId = iprot.readI64();
6610 
        else:
6611 
          iprot.skip(ftype)
6612 
      else:
6613 
        iprot.skip(ftype)
6614 
      iprot.readFieldEnd()
6615 
    iprot.readStructEnd()
6616 
 
6617 
  def write(self, oprot):
6618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6620 
      return
6621 
    oprot.writeStructBegin('getDefaultPincode_args')
6622 
    if self.userId != None:
6623 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6624 
      oprot.writeI64(self.userId)
6625 
      oprot.writeFieldEnd()
6626 
    oprot.writeFieldStop()
6627 
    oprot.writeStructEnd()
6628 
 
6629 
  def __repr__(self):
6630 
    L = ['%s=%r' % (key, value)
6631 
      for key, value in self.__dict__.iteritems()]
6632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6633 
 
6634 
  def __eq__(self, other):
6635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6636 
 
6637 
  def __ne__(self, other):
6638 
    return not (self == other)
6639 
 
6640 
class getDefaultPincode_result:
6641 
  """
6642 
  Attributes:
6643 
   - success
6644 
   - ucx
6645 
  """
6646 
 
6647 
  thrift_spec = (
6648 
    (0, TType.STRING, 'success', None, None, ), # 0
6649 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6650 
  )
6651 
 
6652 
  def __init__(self, success=None, ucx=None,):
6653 
    self.success = success
6654 
    self.ucx = ucx
6655 
 
6656 
  def read(self, iprot):
6657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6659 
      return
6660 
    iprot.readStructBegin()
6661 
    while True:
6662 
      (fname, ftype, fid) = iprot.readFieldBegin()
6663 
      if ftype == TType.STOP:
6664 
        break
6665 
      if fid == 0:
6666 
        if ftype == TType.STRING:
6667 
          self.success = iprot.readString();
6668 
        else:
6669 
          iprot.skip(ftype)
6670 
      elif fid == 1:
6671 
        if ftype == TType.STRUCT:
6672 
          self.ucx = UserContextException()
6673 
          self.ucx.read(iprot)
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      else:
6677 
        iprot.skip(ftype)
6678 
      iprot.readFieldEnd()
6679 
    iprot.readStructEnd()
6680 
 
6681 
  def write(self, oprot):
6682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6684 
      return
6685 
    oprot.writeStructBegin('getDefaultPincode_result')
6686 
    if self.success != None:
6687 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6688 
      oprot.writeString(self.success)
6689 
      oprot.writeFieldEnd()
6690 
    if self.ucx != None:
6691 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6692 
      self.ucx.write(oprot)
6693 
      oprot.writeFieldEnd()
6694 
    oprot.writeFieldStop()
6695 
    oprot.writeStructEnd()
6696 
 
6697 
  def __repr__(self):
6698 
    L = ['%s=%r' % (key, value)
6699 
      for key, value in self.__dict__.iteritems()]
6700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6701 
 
6702 
  def __eq__(self, other):
6703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6704 
 
6705 
  def __ne__(self, other):
6706 
    return not (self == other)
6707 
 
1274 varun.gupt 6708 
class saveUserCommunication_args:
6709 
  """
6710 
  Attributes:
6711 
   - userId
6712 
   - replyTo
6713 
   - communicationType
6714 
   - orderId
6715 
   - airwaybillNo
6716 
   - productName
6717 
   - subject
6718 
   - message
6719 
  """
6720 
 
6721 
  thrift_spec = (
6722 
    None, # 0
6723 
    (1, TType.I64, 'userId', None, None, ), # 1
6724 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6725 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6726 
    (4, TType.I64, 'orderId', None, None, ), # 4
6727 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6728 
    (6, TType.STRING, 'productName', None, None, ), # 6
6729 
    (7, TType.STRING, 'subject', None, None, ), # 7
6730 
    (8, TType.STRING, 'message', None, None, ), # 8
6731 
  )
6732 
 
6733 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6734 
    self.userId = userId
6735 
    self.replyTo = replyTo
6736 
    self.communicationType = communicationType
6737 
    self.orderId = orderId
6738 
    self.airwaybillNo = airwaybillNo
6739 
    self.productName = productName
6740 
    self.subject = subject
6741 
    self.message = message
6742 
 
6743 
  def read(self, iprot):
6744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6746 
      return
6747 
    iprot.readStructBegin()
6748 
    while True:
6749 
      (fname, ftype, fid) = iprot.readFieldBegin()
6750 
      if ftype == TType.STOP:
6751 
        break
6752 
      if fid == 1:
6753 
        if ftype == TType.I64:
6754 
          self.userId = iprot.readI64();
6755 
        else:
6756 
          iprot.skip(ftype)
6757 
      elif fid == 2:
6758 
        if ftype == TType.STRING:
6759 
          self.replyTo = iprot.readString();
6760 
        else:
6761 
          iprot.skip(ftype)
6762 
      elif fid == 3:
6763 
        if ftype == TType.I64:
6764 
          self.communicationType = iprot.readI64();
6765 
        else:
6766 
          iprot.skip(ftype)
6767 
      elif fid == 4:
6768 
        if ftype == TType.I64:
6769 
          self.orderId = iprot.readI64();
6770 
        else:
6771 
          iprot.skip(ftype)
6772 
      elif fid == 5:
6773 
        if ftype == TType.STRING:
6774 
          self.airwaybillNo = iprot.readString();
6775 
        else:
6776 
          iprot.skip(ftype)
6777 
      elif fid == 6:
6778 
        if ftype == TType.STRING:
6779 
          self.productName = iprot.readString();
6780 
        else:
6781 
          iprot.skip(ftype)
6782 
      elif fid == 7:
6783 
        if ftype == TType.STRING:
6784 
          self.subject = iprot.readString();
6785 
        else:
6786 
          iprot.skip(ftype)
6787 
      elif fid == 8:
6788 
        if ftype == TType.STRING:
6789 
          self.message = iprot.readString();
6790 
        else:
6791 
          iprot.skip(ftype)
6792 
      else:
6793 
        iprot.skip(ftype)
6794 
      iprot.readFieldEnd()
6795 
    iprot.readStructEnd()
6796 
 
6797 
  def write(self, oprot):
6798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6800 
      return
6801 
    oprot.writeStructBegin('saveUserCommunication_args')
6802 
    if self.userId != None:
6803 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6804 
      oprot.writeI64(self.userId)
6805 
      oprot.writeFieldEnd()
6806 
    if self.replyTo != None:
6807 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6808 
      oprot.writeString(self.replyTo)
6809 
      oprot.writeFieldEnd()
6810 
    if self.communicationType != None:
6811 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6812 
      oprot.writeI64(self.communicationType)
6813 
      oprot.writeFieldEnd()
6814 
    if self.orderId != None:
6815 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6816 
      oprot.writeI64(self.orderId)
6817 
      oprot.writeFieldEnd()
6818 
    if self.airwaybillNo != None:
6819 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6820 
      oprot.writeString(self.airwaybillNo)
6821 
      oprot.writeFieldEnd()
6822 
    if self.productName != None:
6823 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6824 
      oprot.writeString(self.productName)
6825 
      oprot.writeFieldEnd()
6826 
    if self.subject != None:
6827 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6828 
      oprot.writeString(self.subject)
6829 
      oprot.writeFieldEnd()
6830 
    if self.message != None:
6831 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6832 
      oprot.writeString(self.message)
6833 
      oprot.writeFieldEnd()
6834 
    oprot.writeFieldStop()
6835 
    oprot.writeStructEnd()
6836 
 
6837 
  def __repr__(self):
6838 
    L = ['%s=%r' % (key, value)
6839 
      for key, value in self.__dict__.iteritems()]
6840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6841 
 
6842 
  def __eq__(self, other):
6843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6844 
 
6845 
  def __ne__(self, other):
6846 
    return not (self == other)
6847 
 
6848 
class saveUserCommunication_result:
6849 
  """
6850 
  Attributes:
6851 
   - success
6852 
   - ucx
6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    (0, TType.BOOL, 'success', None, None, ), # 0
6857 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6858 
  )
6859 
 
6860 
  def __init__(self, success=None, ucx=None,):
6861 
    self.success = success
6862 
    self.ucx = ucx
6863 
 
6864 
  def read(self, iprot):
6865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6867 
      return
6868 
    iprot.readStructBegin()
6869 
    while True:
6870 
      (fname, ftype, fid) = iprot.readFieldBegin()
6871 
      if ftype == TType.STOP:
6872 
        break
6873 
      if fid == 0:
6874 
        if ftype == TType.BOOL:
6875 
          self.success = iprot.readBool();
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      elif fid == 1:
6879 
        if ftype == TType.STRUCT:
6880 
          self.ucx = UserCommunicationException()
6881 
          self.ucx.read(iprot)
6882 
        else:
6883 
          iprot.skip(ftype)
6884 
      else:
6885 
        iprot.skip(ftype)
6886 
      iprot.readFieldEnd()
6887 
    iprot.readStructEnd()
6888 
 
6889 
  def write(self, oprot):
6890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6892 
      return
6893 
    oprot.writeStructBegin('saveUserCommunication_result')
6894 
    if self.success != None:
6895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6896 
      oprot.writeBool(self.success)
6897 
      oprot.writeFieldEnd()
6898 
    if self.ucx != None:
6899 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6900 
      self.ucx.write(oprot)
6901 
      oprot.writeFieldEnd()
6902 
    oprot.writeFieldStop()
6903 
    oprot.writeStructEnd()
6904 
 
6905 
  def __repr__(self):
6906 
    L = ['%s=%r' % (key, value)
6907 
      for key, value in self.__dict__.iteritems()]
6908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6909 
 
6910 
  def __eq__(self, other):
6911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6912 
 
6913 
  def __ne__(self, other):
6914 
    return not (self == other)
6915 
 
1590 varun.gupt 6916 
class getUserCommunicationById_args:
6917 
  """
6918 
  Attributes:
6919 
   - id
6920 
  """
6921 
 
6922 
  thrift_spec = (
6923 
    None, # 0
6924 
    (1, TType.I64, 'id', None, None, ), # 1
6925 
  )
6926 
 
6927 
  def __init__(self, id=None,):
6928 
    self.id = id
6929 
 
6930 
  def read(self, iprot):
6931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6933 
      return
6934 
    iprot.readStructBegin()
6935 
    while True:
6936 
      (fname, ftype, fid) = iprot.readFieldBegin()
6937 
      if ftype == TType.STOP:
6938 
        break
6939 
      if fid == 1:
6940 
        if ftype == TType.I64:
6941 
          self.id = iprot.readI64();
6942 
        else:
6943 
          iprot.skip(ftype)
6944 
      else:
6945 
        iprot.skip(ftype)
6946 
      iprot.readFieldEnd()
6947 
    iprot.readStructEnd()
6948 
 
6949 
  def write(self, oprot):
6950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6952 
      return
6953 
    oprot.writeStructBegin('getUserCommunicationById_args')
6954 
    if self.id != None:
6955 
      oprot.writeFieldBegin('id', TType.I64, 1)
6956 
      oprot.writeI64(self.id)
6957 
      oprot.writeFieldEnd()
6958 
    oprot.writeFieldStop()
6959 
    oprot.writeStructEnd()
6960 
 
6961 
  def __repr__(self):
6962 
    L = ['%s=%r' % (key, value)
6963 
      for key, value in self.__dict__.iteritems()]
6964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6965 
 
6966 
  def __eq__(self, other):
6967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6968 
 
6969 
  def __ne__(self, other):
6970 
    return not (self == other)
6971 
 
6972 
class getUserCommunicationById_result:
6973 
  """
6974 
  Attributes:
6975 
   - success
6976 
   - ucx
6977 
  """
6978 
 
6979 
  thrift_spec = (
6980 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6981 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6982 
  )
6983 
 
6984 
  def __init__(self, success=None, ucx=None,):
6985 
    self.success = success
6986 
    self.ucx = ucx
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 0:
6998 
        if ftype == TType.STRUCT:
6999 
          self.success = UserCommunication()
7000 
          self.success.read(iprot)
7001 
        else:
7002 
          iprot.skip(ftype)
7003 
      elif fid == 1:
7004 
        if ftype == TType.STRUCT:
7005 
          self.ucx = UserCommunicationException()
7006 
          self.ucx.read(iprot)
7007 
        else:
7008 
          iprot.skip(ftype)
7009 
      else:
7010 
        iprot.skip(ftype)
7011 
      iprot.readFieldEnd()
7012 
    iprot.readStructEnd()
7013 
 
7014 
  def write(self, oprot):
7015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7017 
      return
7018 
    oprot.writeStructBegin('getUserCommunicationById_result')
7019 
    if self.success != None:
7020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7021 
      self.success.write(oprot)
7022 
      oprot.writeFieldEnd()
7023 
    if self.ucx != None:
7024 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7025 
      self.ucx.write(oprot)
7026 
      oprot.writeFieldEnd()
7027 
    oprot.writeFieldStop()
7028 
    oprot.writeStructEnd()
7029 
 
7030 
  def __repr__(self):
7031 
    L = ['%s=%r' % (key, value)
7032 
      for key, value in self.__dict__.iteritems()]
7033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7034 
 
7035 
  def __eq__(self, other):
7036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7037 
 
7038 
  def __ne__(self, other):
7039 
    return not (self == other)
7040 
 
7041 
class getUserCommunicationByUser_args:
7042 
  """
7043 
  Attributes:
7044 
   - userId
7045 
  """
7046 
 
7047 
  thrift_spec = (
7048 
    None, # 0
7049 
    (1, TType.I64, 'userId', None, None, ), # 1
7050 
  )
7051 
 
7052 
  def __init__(self, userId=None,):
7053 
    self.userId = userId
7054 
 
7055 
  def read(self, iprot):
7056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7058 
      return
7059 
    iprot.readStructBegin()
7060 
    while True:
7061 
      (fname, ftype, fid) = iprot.readFieldBegin()
7062 
      if ftype == TType.STOP:
7063 
        break
7064 
      if fid == 1:
7065 
        if ftype == TType.I64:
7066 
          self.userId = iprot.readI64();
7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      else:
7070 
        iprot.skip(ftype)
7071 
      iprot.readFieldEnd()
7072 
    iprot.readStructEnd()
7073 
 
7074 
  def write(self, oprot):
7075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7077 
      return
7078 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
7079 
    if self.userId != None:
7080 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7081 
      oprot.writeI64(self.userId)
7082 
      oprot.writeFieldEnd()
7083 
    oprot.writeFieldStop()
7084 
    oprot.writeStructEnd()
7085 
 
7086 
  def __repr__(self):
7087 
    L = ['%s=%r' % (key, value)
7088 
      for key, value in self.__dict__.iteritems()]
7089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7090 
 
7091 
  def __eq__(self, other):
7092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7093 
 
7094 
  def __ne__(self, other):
7095 
    return not (self == other)
7096 
 
7097 
class getUserCommunicationByUser_result:
7098 
  """
7099 
  Attributes:
7100 
   - success
7101 
   - ucx
7102 
  """
7103 
 
7104 
  thrift_spec = (
7105 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7106 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7107 
  )
7108 
 
7109 
  def __init__(self, success=None, ucx=None,):
7110 
    self.success = success
7111 
    self.ucx = ucx
7112 
 
7113 
  def read(self, iprot):
7114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7116 
      return
7117 
    iprot.readStructBegin()
7118 
    while True:
7119 
      (fname, ftype, fid) = iprot.readFieldBegin()
7120 
      if ftype == TType.STOP:
7121 
        break
7122 
      if fid == 0:
7123 
        if ftype == TType.LIST:
7124 
          self.success = []
2981 rajveer 7125 
          (_etype38, _size35) = iprot.readListBegin()
7126 
          for _i39 in xrange(_size35):
7127 
            _elem40 = UserCommunication()
7128 
            _elem40.read(iprot)
7129 
            self.success.append(_elem40)
1590 varun.gupt 7130 
          iprot.readListEnd()
7131 
        else:
7132 
          iprot.skip(ftype)
7133 
      elif fid == 1:
7134 
        if ftype == TType.STRUCT:
7135 
          self.ucx = UserCommunicationException()
7136 
          self.ucx.read(iprot)
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      else:
7140 
        iprot.skip(ftype)
7141 
      iprot.readFieldEnd()
7142 
    iprot.readStructEnd()
7143 
 
7144 
  def write(self, oprot):
7145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7147 
      return
7148 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7149 
    if self.success != None:
7150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7152 
      for iter41 in self.success:
7153 
        iter41.write(oprot)
1590 varun.gupt 7154 
      oprot.writeListEnd()
7155 
      oprot.writeFieldEnd()
7156 
    if self.ucx != None:
7157 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7158 
      self.ucx.write(oprot)
7159 
      oprot.writeFieldEnd()
7160 
    oprot.writeFieldStop()
7161 
    oprot.writeStructEnd()
7162 
 
7163 
  def __repr__(self):
7164 
    L = ['%s=%r' % (key, value)
7165 
      for key, value in self.__dict__.iteritems()]
7166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7167 
 
7168 
  def __eq__(self, other):
7169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7170 
 
7171 
  def __ne__(self, other):
7172 
    return not (self == other)
7173 
 
7174 
class getAllUserCommunications_args:
7175 
 
7176 
  thrift_spec = (
7177 
  )
7178 
 
7179 
  def read(self, iprot):
7180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7182 
      return
7183 
    iprot.readStructBegin()
7184 
    while True:
7185 
      (fname, ftype, fid) = iprot.readFieldBegin()
7186 
      if ftype == TType.STOP:
7187 
        break
7188 
      else:
7189 
        iprot.skip(ftype)
7190 
      iprot.readFieldEnd()
7191 
    iprot.readStructEnd()
7192 
 
7193 
  def write(self, oprot):
7194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7196 
      return
7197 
    oprot.writeStructBegin('getAllUserCommunications_args')
7198 
    oprot.writeFieldStop()
7199 
    oprot.writeStructEnd()
7200 
 
7201 
  def __repr__(self):
7202 
    L = ['%s=%r' % (key, value)
7203 
      for key, value in self.__dict__.iteritems()]
7204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7205 
 
7206 
  def __eq__(self, other):
7207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7208 
 
7209 
  def __ne__(self, other):
7210 
    return not (self == other)
7211 
 
7212 
class getAllUserCommunications_result:
7213 
  """
7214 
  Attributes:
7215 
   - success
7216 
   - ucx
7217 
  """
7218 
 
7219 
  thrift_spec = (
7220 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7221 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7222 
  )
7223 
 
7224 
  def __init__(self, success=None, ucx=None,):
7225 
    self.success = success
7226 
    self.ucx = ucx
7227 
 
7228 
  def read(self, iprot):
7229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7231 
      return
7232 
    iprot.readStructBegin()
7233 
    while True:
7234 
      (fname, ftype, fid) = iprot.readFieldBegin()
7235 
      if ftype == TType.STOP:
7236 
        break
7237 
      if fid == 0:
7238 
        if ftype == TType.LIST:
7239 
          self.success = []
2981 rajveer 7240 
          (_etype45, _size42) = iprot.readListBegin()
7241 
          for _i46 in xrange(_size42):
7242 
            _elem47 = UserCommunication()
7243 
            _elem47.read(iprot)
7244 
            self.success.append(_elem47)
1590 varun.gupt 7245 
          iprot.readListEnd()
7246 
        else:
7247 
          iprot.skip(ftype)
7248 
      elif fid == 1:
7249 
        if ftype == TType.STRUCT:
7250 
          self.ucx = UserCommunicationException()
7251 
          self.ucx.read(iprot)
7252 
        else:
7253 
          iprot.skip(ftype)
7254 
      else:
7255 
        iprot.skip(ftype)
7256 
      iprot.readFieldEnd()
7257 
    iprot.readStructEnd()
7258 
 
7259 
  def write(self, oprot):
7260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7262 
      return
7263 
    oprot.writeStructBegin('getAllUserCommunications_result')
7264 
    if self.success != None:
7265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7267 
      for iter48 in self.success:
7268 
        iter48.write(oprot)
1590 varun.gupt 7269 
      oprot.writeListEnd()
7270 
      oprot.writeFieldEnd()
7271 
    if self.ucx != None:
7272 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7273 
      self.ucx.write(oprot)
7274 
      oprot.writeFieldEnd()
7275 
    oprot.writeFieldStop()
7276 
    oprot.writeStructEnd()
7277 
 
7278 
  def __repr__(self):
7279 
    L = ['%s=%r' % (key, value)
7280 
      for key, value in self.__dict__.iteritems()]
7281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7282 
 
7283 
  def __eq__(self, other):
7284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7285 
 
7286 
  def __ne__(self, other):
7287 
    return not (self == other)
7288 
 
1845 vikas 7289 
class createMasterAffiliate_args:
7290 
  """
7291 
  Attributes:
7292 
   - name
1859 vikas 7293 
   - addedOn
1845 vikas 7294 
  """
7295 
 
7296 
  thrift_spec = (
7297 
    None, # 0
7298 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7299 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7300 
  )
7301 
 
1859 vikas 7302 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7303 
    self.name = name
1859 vikas 7304 
    self.addedOn = addedOn
1845 vikas 7305 
 
7306 
  def read(self, iprot):
7307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7309 
      return
7310 
    iprot.readStructBegin()
7311 
    while True:
7312 
      (fname, ftype, fid) = iprot.readFieldBegin()
7313 
      if ftype == TType.STOP:
7314 
        break
7315 
      if fid == 1:
7316 
        if ftype == TType.STRING:
7317 
          self.name = iprot.readString();
7318 
        else:
7319 
          iprot.skip(ftype)
1859 vikas 7320 
      elif fid == 2:
7321 
        if ftype == TType.I64:
7322 
          self.addedOn = iprot.readI64();
7323 
        else:
7324 
          iprot.skip(ftype)
1845 vikas 7325 
      else:
7326 
        iprot.skip(ftype)
7327 
      iprot.readFieldEnd()
7328 
    iprot.readStructEnd()
7329 
 
7330 
  def write(self, oprot):
7331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7333 
      return
7334 
    oprot.writeStructBegin('createMasterAffiliate_args')
7335 
    if self.name != None:
7336 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7337 
      oprot.writeString(self.name)
7338 
      oprot.writeFieldEnd()
1859 vikas 7339 
    if self.addedOn != None:
7340 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7341 
      oprot.writeI64(self.addedOn)
7342 
      oprot.writeFieldEnd()
1845 vikas 7343 
    oprot.writeFieldStop()
7344 
    oprot.writeStructEnd()
7345 
 
7346 
  def __repr__(self):
7347 
    L = ['%s=%r' % (key, value)
7348 
      for key, value in self.__dict__.iteritems()]
7349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7350 
 
7351 
  def __eq__(self, other):
7352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7353 
 
7354 
  def __ne__(self, other):
7355 
    return not (self == other)
7356 
 
7357 
class createMasterAffiliate_result:
7358 
  """
7359 
  Attributes:
7360 
   - success
7361 
   - utx
7362 
  """
7363 
 
7364 
  thrift_spec = (
7365 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7366 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7367 
  )
7368 
 
7369 
  def __init__(self, success=None, utx=None,):
7370 
    self.success = success
7371 
    self.utx = utx
7372 
 
7373 
  def read(self, iprot):
7374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7376 
      return
7377 
    iprot.readStructBegin()
7378 
    while True:
7379 
      (fname, ftype, fid) = iprot.readFieldBegin()
7380 
      if ftype == TType.STOP:
7381 
        break
7382 
      if fid == 0:
7383 
        if ftype == TType.STRUCT:
7384 
          self.success = MasterAffiliate()
7385 
          self.success.read(iprot)
7386 
        else:
7387 
          iprot.skip(ftype)
7388 
      elif fid == 1:
7389 
        if ftype == TType.STRUCT:
1996 vikas 7390 
          self.utx = UserAffiliateException()
1845 vikas 7391 
          self.utx.read(iprot)
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      else:
7395 
        iprot.skip(ftype)
7396 
      iprot.readFieldEnd()
7397 
    iprot.readStructEnd()
7398 
 
7399 
  def write(self, oprot):
7400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7402 
      return
7403 
    oprot.writeStructBegin('createMasterAffiliate_result')
7404 
    if self.success != None:
7405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7406 
      self.success.write(oprot)
7407 
      oprot.writeFieldEnd()
7408 
    if self.utx != None:
7409 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7410 
      self.utx.write(oprot)
7411 
      oprot.writeFieldEnd()
7412 
    oprot.writeFieldStop()
7413 
    oprot.writeStructEnd()
7414 
 
7415 
  def __repr__(self):
7416 
    L = ['%s=%r' % (key, value)
7417 
      for key, value in self.__dict__.iteritems()]
7418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7419 
 
7420 
  def __eq__(self, other):
7421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7422 
 
7423 
  def __ne__(self, other):
7424 
    return not (self == other)
7425 
 
1899 vikas 7426 
class getAllMasterAffiliates_args:
7427 
 
7428 
  thrift_spec = (
7429 
  )
7430 
 
7431 
  def read(self, iprot):
7432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7434 
      return
7435 
    iprot.readStructBegin()
7436 
    while True:
7437 
      (fname, ftype, fid) = iprot.readFieldBegin()
7438 
      if ftype == TType.STOP:
7439 
        break
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('getAllMasterAffiliates_args')
7450 
    oprot.writeFieldStop()
7451 
    oprot.writeStructEnd()
7452 
 
7453 
  def __repr__(self):
7454 
    L = ['%s=%r' % (key, value)
7455 
      for key, value in self.__dict__.iteritems()]
7456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7457 
 
7458 
  def __eq__(self, other):
7459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7460 
 
7461 
  def __ne__(self, other):
7462 
    return not (self == other)
7463 
 
7464 
class getAllMasterAffiliates_result:
7465 
  """
7466 
  Attributes:
7467 
   - success
7468 
   - utx
7469 
  """
7470 
 
7471 
  thrift_spec = (
7472 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7473 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7474 
  )
7475 
 
7476 
  def __init__(self, success=None, utx=None,):
7477 
    self.success = success
7478 
    self.utx = utx
7479 
 
7480 
  def read(self, iprot):
7481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7483 
      return
7484 
    iprot.readStructBegin()
7485 
    while True:
7486 
      (fname, ftype, fid) = iprot.readFieldBegin()
7487 
      if ftype == TType.STOP:
7488 
        break
7489 
      if fid == 0:
7490 
        if ftype == TType.LIST:
7491 
          self.success = []
2981 rajveer 7492 
          (_etype52, _size49) = iprot.readListBegin()
7493 
          for _i53 in xrange(_size49):
7494 
            _elem54 = MasterAffiliate()
7495 
            _elem54.read(iprot)
7496 
            self.success.append(_elem54)
1899 vikas 7497 
          iprot.readListEnd()
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      elif fid == 1:
7501 
        if ftype == TType.STRUCT:
1996 vikas 7502 
          self.utx = UserAffiliateException()
1899 vikas 7503 
          self.utx.read(iprot)
7504 
        else:
7505 
          iprot.skip(ftype)
7506 
      else:
7507 
        iprot.skip(ftype)
7508 
      iprot.readFieldEnd()
7509 
    iprot.readStructEnd()
7510 
 
7511 
  def write(self, oprot):
7512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7514 
      return
7515 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7516 
    if self.success != None:
7517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7519 
      for iter55 in self.success:
7520 
        iter55.write(oprot)
1899 vikas 7521 
      oprot.writeListEnd()
7522 
      oprot.writeFieldEnd()
7523 
    if self.utx != None:
7524 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7525 
      self.utx.write(oprot)
7526 
      oprot.writeFieldEnd()
7527 
    oprot.writeFieldStop()
7528 
    oprot.writeStructEnd()
7529 
 
7530 
  def __repr__(self):
7531 
    L = ['%s=%r' % (key, value)
7532 
      for key, value in self.__dict__.iteritems()]
7533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7534 
 
7535 
  def __eq__(self, other):
7536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7537 
 
7538 
  def __ne__(self, other):
7539 
    return not (self == other)
7540 
 
1845 vikas 7541 
class getMasterAffiliateById_args:
7542 
  """
7543 
  Attributes:
7544 
   - id
7545 
  """
7546 
 
7547 
  thrift_spec = (
7548 
    None, # 0
7549 
    (1, TType.I64, 'id', None, None, ), # 1
7550 
  )
7551 
 
7552 
  def __init__(self, id=None,):
7553 
    self.id = id
7554 
 
7555 
  def read(self, iprot):
7556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7558 
      return
7559 
    iprot.readStructBegin()
7560 
    while True:
7561 
      (fname, ftype, fid) = iprot.readFieldBegin()
7562 
      if ftype == TType.STOP:
7563 
        break
7564 
      if fid == 1:
7565 
        if ftype == TType.I64:
7566 
          self.id = iprot.readI64();
7567 
        else:
7568 
          iprot.skip(ftype)
7569 
      else:
7570 
        iprot.skip(ftype)
7571 
      iprot.readFieldEnd()
7572 
    iprot.readStructEnd()
7573 
 
7574 
  def write(self, oprot):
7575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7577 
      return
7578 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7579 
    if self.id != None:
7580 
      oprot.writeFieldBegin('id', TType.I64, 1)
7581 
      oprot.writeI64(self.id)
7582 
      oprot.writeFieldEnd()
7583 
    oprot.writeFieldStop()
7584 
    oprot.writeStructEnd()
7585 
 
7586 
  def __repr__(self):
7587 
    L = ['%s=%r' % (key, value)
7588 
      for key, value in self.__dict__.iteritems()]
7589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7590 
 
7591 
  def __eq__(self, other):
7592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7593 
 
7594 
  def __ne__(self, other):
7595 
    return not (self == other)
7596 
 
7597 
class getMasterAffiliateById_result:
7598 
  """
7599 
  Attributes:
7600 
   - success
7601 
   - utx
7602 
  """
7603 
 
7604 
  thrift_spec = (
7605 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7606 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7607 
  )
7608 
 
7609 
  def __init__(self, success=None, utx=None,):
7610 
    self.success = success
7611 
    self.utx = utx
7612 
 
7613 
  def read(self, iprot):
7614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7616 
      return
7617 
    iprot.readStructBegin()
7618 
    while True:
7619 
      (fname, ftype, fid) = iprot.readFieldBegin()
7620 
      if ftype == TType.STOP:
7621 
        break
7622 
      if fid == 0:
7623 
        if ftype == TType.STRUCT:
7624 
          self.success = MasterAffiliate()
7625 
          self.success.read(iprot)
7626 
        else:
7627 
          iprot.skip(ftype)
7628 
      elif fid == 1:
7629 
        if ftype == TType.STRUCT:
1996 vikas 7630 
          self.utx = UserAffiliateException()
1845 vikas 7631 
          self.utx.read(iprot)
7632 
        else:
7633 
          iprot.skip(ftype)
7634 
      else:
7635 
        iprot.skip(ftype)
7636 
      iprot.readFieldEnd()
7637 
    iprot.readStructEnd()
7638 
 
7639 
  def write(self, oprot):
7640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7642 
      return
7643 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7644 
    if self.success != None:
7645 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7646 
      self.success.write(oprot)
7647 
      oprot.writeFieldEnd()
7648 
    if self.utx != None:
7649 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7650 
      self.utx.write(oprot)
7651 
      oprot.writeFieldEnd()
7652 
    oprot.writeFieldStop()
7653 
    oprot.writeStructEnd()
7654 
 
7655 
  def __repr__(self):
7656 
    L = ['%s=%r' % (key, value)
7657 
      for key, value in self.__dict__.iteritems()]
7658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7659 
 
7660 
  def __eq__(self, other):
7661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7662 
 
7663 
  def __ne__(self, other):
7664 
    return not (self == other)
7665 
 
7666 
class getMasterAffiliateByName_args:
7667 
  """
7668 
  Attributes:
7669 
   - name
7670 
  """
7671 
 
7672 
  thrift_spec = (
7673 
    None, # 0
7674 
    (1, TType.STRING, 'name', None, None, ), # 1
7675 
  )
7676 
 
7677 
  def __init__(self, name=None,):
7678 
    self.name = name
7679 
 
7680 
  def read(self, iprot):
7681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7683 
      return
7684 
    iprot.readStructBegin()
7685 
    while True:
7686 
      (fname, ftype, fid) = iprot.readFieldBegin()
7687 
      if ftype == TType.STOP:
7688 
        break
7689 
      if fid == 1:
7690 
        if ftype == TType.STRING:
7691 
          self.name = iprot.readString();
7692 
        else:
7693 
          iprot.skip(ftype)
7694 
      else:
7695 
        iprot.skip(ftype)
7696 
      iprot.readFieldEnd()
7697 
    iprot.readStructEnd()
7698 
 
7699 
  def write(self, oprot):
7700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7702 
      return
7703 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7704 
    if self.name != None:
7705 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7706 
      oprot.writeString(self.name)
7707 
      oprot.writeFieldEnd()
7708 
    oprot.writeFieldStop()
7709 
    oprot.writeStructEnd()
7710 
 
7711 
  def __repr__(self):
7712 
    L = ['%s=%r' % (key, value)
7713 
      for key, value in self.__dict__.iteritems()]
7714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7715 
 
7716 
  def __eq__(self, other):
7717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7718 
 
7719 
  def __ne__(self, other):
7720 
    return not (self == other)
7721 
 
7722 
class getMasterAffiliateByName_result:
7723 
  """
7724 
  Attributes:
7725 
   - success
7726 
   - utx
7727 
  """
7728 
 
7729 
  thrift_spec = (
7730 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7731 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7732 
  )
7733 
 
7734 
  def __init__(self, success=None, utx=None,):
7735 
    self.success = success
7736 
    self.utx = utx
7737 
 
7738 
  def read(self, iprot):
7739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7741 
      return
7742 
    iprot.readStructBegin()
7743 
    while True:
7744 
      (fname, ftype, fid) = iprot.readFieldBegin()
7745 
      if ftype == TType.STOP:
7746 
        break
7747 
      if fid == 0:
7748 
        if ftype == TType.STRUCT:
7749 
          self.success = MasterAffiliate()
7750 
          self.success.read(iprot)
7751 
        else:
7752 
          iprot.skip(ftype)
7753 
      elif fid == 1:
7754 
        if ftype == TType.STRUCT:
1996 vikas 7755 
          self.utx = UserAffiliateException()
1845 vikas 7756 
          self.utx.read(iprot)
7757 
        else:
7758 
          iprot.skip(ftype)
7759 
      else:
7760 
        iprot.skip(ftype)
7761 
      iprot.readFieldEnd()
7762 
    iprot.readStructEnd()
7763 
 
7764 
  def write(self, oprot):
7765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7767 
      return
7768 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7769 
    if self.success != None:
7770 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7771 
      self.success.write(oprot)
7772 
      oprot.writeFieldEnd()
7773 
    if self.utx != None:
7774 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7775 
      self.utx.write(oprot)
7776 
      oprot.writeFieldEnd()
7777 
    oprot.writeFieldStop()
7778 
    oprot.writeStructEnd()
7779 
 
7780 
  def __repr__(self):
7781 
    L = ['%s=%r' % (key, value)
7782 
      for key, value in self.__dict__.iteritems()]
7783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7784 
 
7785 
  def __eq__(self, other):
7786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7787 
 
7788 
  def __ne__(self, other):
7789 
    return not (self == other)
7790 
 
7791 
class createAffiliate_args:
7792 
  """
7793 
  Attributes:
7794 
   - name
7795 
   - url
7796 
   - masterAffiliateId
1859 vikas 7797 
   - addedOn
1845 vikas 7798 
  """
7799 
 
7800 
  thrift_spec = (
7801 
    None, # 0
7802 
    (1, TType.STRING, 'name', None, None, ), # 1
7803 
    (2, TType.STRING, 'url', None, None, ), # 2
7804 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7805 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7806 
  )
7807 
 
1859 vikas 7808 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7809 
    self.name = name
7810 
    self.url = url
7811 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7812 
    self.addedOn = addedOn
1845 vikas 7813 
 
7814 
  def read(self, iprot):
7815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7817 
      return
7818 
    iprot.readStructBegin()
7819 
    while True:
7820 
      (fname, ftype, fid) = iprot.readFieldBegin()
7821 
      if ftype == TType.STOP:
7822 
        break
7823 
      if fid == 1:
7824 
        if ftype == TType.STRING:
7825 
          self.name = iprot.readString();
7826 
        else:
7827 
          iprot.skip(ftype)
7828 
      elif fid == 2:
7829 
        if ftype == TType.STRING:
7830 
          self.url = iprot.readString();
7831 
        else:
7832 
          iprot.skip(ftype)
7833 
      elif fid == 3:
7834 
        if ftype == TType.I64:
7835 
          self.masterAffiliateId = iprot.readI64();
7836 
        else:
7837 
          iprot.skip(ftype)
1859 vikas 7838 
      elif fid == 4:
7839 
        if ftype == TType.I64:
7840 
          self.addedOn = iprot.readI64();
7841 
        else:
7842 
          iprot.skip(ftype)
1845 vikas 7843 
      else:
7844 
        iprot.skip(ftype)
7845 
      iprot.readFieldEnd()
7846 
    iprot.readStructEnd()
7847 
 
7848 
  def write(self, oprot):
7849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7851 
      return
7852 
    oprot.writeStructBegin('createAffiliate_args')
7853 
    if self.name != None:
7854 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7855 
      oprot.writeString(self.name)
7856 
      oprot.writeFieldEnd()
7857 
    if self.url != None:
7858 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7859 
      oprot.writeString(self.url)
7860 
      oprot.writeFieldEnd()
7861 
    if self.masterAffiliateId != None:
7862 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7863 
      oprot.writeI64(self.masterAffiliateId)
7864 
      oprot.writeFieldEnd()
1859 vikas 7865 
    if self.addedOn != None:
7866 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7867 
      oprot.writeI64(self.addedOn)
7868 
      oprot.writeFieldEnd()
1845 vikas 7869 
    oprot.writeFieldStop()
7870 
    oprot.writeStructEnd()
7871 
 
7872 
  def __repr__(self):
7873 
    L = ['%s=%r' % (key, value)
7874 
      for key, value in self.__dict__.iteritems()]
7875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7876 
 
7877 
  def __eq__(self, other):
7878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7879 
 
7880 
  def __ne__(self, other):
7881 
    return not (self == other)
7882 
 
7883 
class createAffiliate_result:
7884 
  """
7885 
  Attributes:
7886 
   - success
7887 
   - utx
7888 
  """
7889 
 
7890 
  thrift_spec = (
7891 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7892 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7893 
  )
7894 
 
7895 
  def __init__(self, success=None, utx=None,):
7896 
    self.success = success
7897 
    self.utx = utx
7898 
 
7899 
  def read(self, iprot):
7900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7902 
      return
7903 
    iprot.readStructBegin()
7904 
    while True:
7905 
      (fname, ftype, fid) = iprot.readFieldBegin()
7906 
      if ftype == TType.STOP:
7907 
        break
7908 
      if fid == 0:
7909 
        if ftype == TType.STRUCT:
7910 
          self.success = Affiliate()
7911 
          self.success.read(iprot)
7912 
        else:
7913 
          iprot.skip(ftype)
7914 
      elif fid == 1:
7915 
        if ftype == TType.STRUCT:
1996 vikas 7916 
          self.utx = UserAffiliateException()
1845 vikas 7917 
          self.utx.read(iprot)
7918 
        else:
7919 
          iprot.skip(ftype)
7920 
      else:
7921 
        iprot.skip(ftype)
7922 
      iprot.readFieldEnd()
7923 
    iprot.readStructEnd()
7924 
 
7925 
  def write(self, oprot):
7926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7928 
      return
7929 
    oprot.writeStructBegin('createAffiliate_result')
7930 
    if self.success != None:
7931 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7932 
      self.success.write(oprot)
7933 
      oprot.writeFieldEnd()
7934 
    if self.utx != None:
7935 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7936 
      self.utx.write(oprot)
7937 
      oprot.writeFieldEnd()
7938 
    oprot.writeFieldStop()
7939 
    oprot.writeStructEnd()
7940 
 
7941 
  def __repr__(self):
7942 
    L = ['%s=%r' % (key, value)
7943 
      for key, value in self.__dict__.iteritems()]
7944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7945 
 
7946 
  def __eq__(self, other):
7947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7948 
 
7949 
  def __ne__(self, other):
7950 
    return not (self == other)
7951 
 
7952 
class getAffiliateById_args:
7953 
  """
7954 
  Attributes:
7955 
   - id
7956 
  """
7957 
 
7958 
  thrift_spec = (
7959 
    None, # 0
7960 
    (1, TType.I64, 'id', None, None, ), # 1
7961 
  )
7962 
 
7963 
  def __init__(self, id=None,):
7964 
    self.id = id
7965 
 
7966 
  def read(self, iprot):
7967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7969 
      return
7970 
    iprot.readStructBegin()
7971 
    while True:
7972 
      (fname, ftype, fid) = iprot.readFieldBegin()
7973 
      if ftype == TType.STOP:
7974 
        break
7975 
      if fid == 1:
7976 
        if ftype == TType.I64:
7977 
          self.id = iprot.readI64();
7978 
        else:
7979 
          iprot.skip(ftype)
7980 
      else:
7981 
        iprot.skip(ftype)
7982 
      iprot.readFieldEnd()
7983 
    iprot.readStructEnd()
7984 
 
7985 
  def write(self, oprot):
7986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7988 
      return
7989 
    oprot.writeStructBegin('getAffiliateById_args')
7990 
    if self.id != None:
7991 
      oprot.writeFieldBegin('id', TType.I64, 1)
7992 
      oprot.writeI64(self.id)
7993 
      oprot.writeFieldEnd()
7994 
    oprot.writeFieldStop()
7995 
    oprot.writeStructEnd()
7996 
 
7997 
  def __repr__(self):
7998 
    L = ['%s=%r' % (key, value)
7999 
      for key, value in self.__dict__.iteritems()]
8000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8001 
 
8002 
  def __eq__(self, other):
8003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8004 
 
8005 
  def __ne__(self, other):
8006 
    return not (self == other)
8007 
 
8008 
class getAffiliateById_result:
8009 
  """
8010 
  Attributes:
8011 
   - success
8012 
   - utx
8013 
  """
8014 
 
8015 
  thrift_spec = (
8016 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8017 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8018 
  )
8019 
 
8020 
  def __init__(self, success=None, utx=None,):
8021 
    self.success = success
8022 
    self.utx = utx
8023 
 
8024 
  def read(self, iprot):
8025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8027 
      return
8028 
    iprot.readStructBegin()
8029 
    while True:
8030 
      (fname, ftype, fid) = iprot.readFieldBegin()
8031 
      if ftype == TType.STOP:
8032 
        break
8033 
      if fid == 0:
8034 
        if ftype == TType.STRUCT:
8035 
          self.success = Affiliate()
8036 
          self.success.read(iprot)
8037 
        else:
8038 
          iprot.skip(ftype)
8039 
      elif fid == 1:
8040 
        if ftype == TType.STRUCT:
1996 vikas 8041 
          self.utx = UserAffiliateException()
1845 vikas 8042 
          self.utx.read(iprot)
8043 
        else:
8044 
          iprot.skip(ftype)
8045 
      else:
8046 
        iprot.skip(ftype)
8047 
      iprot.readFieldEnd()
8048 
    iprot.readStructEnd()
8049 
 
8050 
  def write(self, oprot):
8051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8053 
      return
8054 
    oprot.writeStructBegin('getAffiliateById_result')
8055 
    if self.success != None:
8056 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8057 
      self.success.write(oprot)
8058 
      oprot.writeFieldEnd()
8059 
    if self.utx != None:
8060 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8061 
      self.utx.write(oprot)
8062 
      oprot.writeFieldEnd()
8063 
    oprot.writeFieldStop()
8064 
    oprot.writeStructEnd()
8065 
 
8066 
  def __repr__(self):
8067 
    L = ['%s=%r' % (key, value)
8068 
      for key, value in self.__dict__.iteritems()]
8069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8070 
 
8071 
  def __eq__(self, other):
8072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8073 
 
8074 
  def __ne__(self, other):
8075 
    return not (self == other)
8076 
 
8077 
class getAffiliateByName_args:
8078 
  """
8079 
  Attributes:
8080 
   - name
8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    None, # 0
8085 
    (1, TType.STRING, 'name', None, None, ), # 1
8086 
  )
8087 
 
8088 
  def __init__(self, name=None,):
8089 
    self.name = name
8090 
 
8091 
  def read(self, iprot):
8092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8094 
      return
8095 
    iprot.readStructBegin()
8096 
    while True:
8097 
      (fname, ftype, fid) = iprot.readFieldBegin()
8098 
      if ftype == TType.STOP:
8099 
        break
8100 
      if fid == 1:
8101 
        if ftype == TType.STRING:
8102 
          self.name = iprot.readString();
8103 
        else:
8104 
          iprot.skip(ftype)
8105 
      else:
8106 
        iprot.skip(ftype)
8107 
      iprot.readFieldEnd()
8108 
    iprot.readStructEnd()
8109 
 
8110 
  def write(self, oprot):
8111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8113 
      return
8114 
    oprot.writeStructBegin('getAffiliateByName_args')
8115 
    if self.name != None:
8116 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8117 
      oprot.writeString(self.name)
8118 
      oprot.writeFieldEnd()
8119 
    oprot.writeFieldStop()
8120 
    oprot.writeStructEnd()
8121 
 
8122 
  def __repr__(self):
8123 
    L = ['%s=%r' % (key, value)
8124 
      for key, value in self.__dict__.iteritems()]
8125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8126 
 
8127 
  def __eq__(self, other):
8128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8129 
 
8130 
  def __ne__(self, other):
8131 
    return not (self == other)
8132 
 
8133 
class getAffiliateByName_result:
8134 
  """
8135 
  Attributes:
8136 
   - success
8137 
   - utx
8138 
  """
8139 
 
8140 
  thrift_spec = (
8141 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8142 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8143 
  )
8144 
 
8145 
  def __init__(self, success=None, utx=None,):
8146 
    self.success = success
8147 
    self.utx = utx
8148 
 
8149 
  def read(self, iprot):
8150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8152 
      return
8153 
    iprot.readStructBegin()
8154 
    while True:
8155 
      (fname, ftype, fid) = iprot.readFieldBegin()
8156 
      if ftype == TType.STOP:
8157 
        break
8158 
      if fid == 0:
8159 
        if ftype == TType.STRUCT:
8160 
          self.success = Affiliate()
8161 
          self.success.read(iprot)
8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      elif fid == 1:
8165 
        if ftype == TType.STRUCT:
1996 vikas 8166 
          self.utx = UserAffiliateException()
1845 vikas 8167 
          self.utx.read(iprot)
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      else:
8171 
        iprot.skip(ftype)
8172 
      iprot.readFieldEnd()
8173 
    iprot.readStructEnd()
8174 
 
8175 
  def write(self, oprot):
8176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8178 
      return
8179 
    oprot.writeStructBegin('getAffiliateByName_result')
8180 
    if self.success != None:
8181 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8182 
      self.success.write(oprot)
8183 
      oprot.writeFieldEnd()
8184 
    if self.utx != None:
8185 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8186 
      self.utx.write(oprot)
8187 
      oprot.writeFieldEnd()
8188 
    oprot.writeFieldStop()
8189 
    oprot.writeStructEnd()
8190 
 
8191 
  def __repr__(self):
8192 
    L = ['%s=%r' % (key, value)
8193 
      for key, value in self.__dict__.iteritems()]
8194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8195 
 
8196 
  def __eq__(self, other):
8197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8198 
 
8199 
  def __ne__(self, other):
8200 
    return not (self == other)
8201 
 
1996 vikas 8202 
class getTrackerById_args:
1845 vikas 8203 
  """
8204 
  Attributes:
8205 
   - id
8206 
  """
8207 
 
8208 
  thrift_spec = (
8209 
    None, # 0
8210 
    (1, TType.I64, 'id', None, None, ), # 1
8211 
  )
8212 
 
8213 
  def __init__(self, id=None,):
8214 
    self.id = id
8215 
 
8216 
  def read(self, iprot):
8217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8219 
      return
8220 
    iprot.readStructBegin()
8221 
    while True:
8222 
      (fname, ftype, fid) = iprot.readFieldBegin()
8223 
      if ftype == TType.STOP:
8224 
        break
8225 
      if fid == 1:
8226 
        if ftype == TType.I64:
8227 
          self.id = iprot.readI64();
8228 
        else:
8229 
          iprot.skip(ftype)
8230 
      else:
8231 
        iprot.skip(ftype)
8232 
      iprot.readFieldEnd()
8233 
    iprot.readStructEnd()
8234 
 
8235 
  def write(self, oprot):
8236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8238 
      return
1996 vikas 8239 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8240 
    if self.id != None:
8241 
      oprot.writeFieldBegin('id', TType.I64, 1)
8242 
      oprot.writeI64(self.id)
8243 
      oprot.writeFieldEnd()
8244 
    oprot.writeFieldStop()
8245 
    oprot.writeStructEnd()
8246 
 
8247 
  def __repr__(self):
8248 
    L = ['%s=%r' % (key, value)
8249 
      for key, value in self.__dict__.iteritems()]
8250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8251 
 
8252 
  def __eq__(self, other):
8253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8254 
 
8255 
  def __ne__(self, other):
8256 
    return not (self == other)
8257 
 
8258 
class getTrackerById_result:
8259 
  """
8260 
  Attributes:
8261 
   - success
8262 
   - utx
8263 
  """
8264 
 
8265 
  thrift_spec = (
8266 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8267 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8268 
  )
8269 
 
8270 
  def __init__(self, success=None, utx=None,):
8271 
    self.success = success
8272 
    self.utx = utx
8273 
 
8274 
  def read(self, iprot):
8275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8277 
      return
8278 
    iprot.readStructBegin()
8279 
    while True:
8280 
      (fname, ftype, fid) = iprot.readFieldBegin()
8281 
      if ftype == TType.STOP:
8282 
        break
8283 
      if fid == 0:
8284 
        if ftype == TType.STRUCT:
8285 
          self.success = Tracker()
8286 
          self.success.read(iprot)
8287 
        else:
8288 
          iprot.skip(ftype)
8289 
      elif fid == 1:
8290 
        if ftype == TType.STRUCT:
1996 vikas 8291 
          self.utx = UserAffiliateException()
1845 vikas 8292 
          self.utx.read(iprot)
8293 
        else:
8294 
          iprot.skip(ftype)
8295 
      else:
8296 
        iprot.skip(ftype)
8297 
      iprot.readFieldEnd()
8298 
    iprot.readStructEnd()
8299 
 
8300 
  def write(self, oprot):
8301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8303 
      return
8304 
    oprot.writeStructBegin('getTrackerById_result')
8305 
    if self.success != None:
8306 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8307 
      self.success.write(oprot)
8308 
      oprot.writeFieldEnd()
8309 
    if self.utx != None:
8310 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8311 
      self.utx.write(oprot)
8312 
      oprot.writeFieldEnd()
8313 
    oprot.writeFieldStop()
8314 
    oprot.writeStructEnd()
8315 
 
8316 
  def __repr__(self):
8317 
    L = ['%s=%r' % (key, value)
8318 
      for key, value in self.__dict__.iteritems()]
8319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8320 
 
8321 
  def __eq__(self, other):
8322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8323 
 
8324 
  def __ne__(self, other):
8325 
    return not (self == other)
8326 
 
1996 vikas 8327 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8328 
  """
8329 
  Attributes:
1996 vikas 8330 
   - id
1845 vikas 8331 
  """
8332 
 
8333 
  thrift_spec = (
8334 
    None, # 0
1996 vikas 8335 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8336 
  )
8337 
 
1996 vikas 8338 
  def __init__(self, id=None,):
8339 
    self.id = id
1845 vikas 8340 
 
8341 
  def read(self, iprot):
8342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8344 
      return
8345 
    iprot.readStructBegin()
8346 
    while True:
8347 
      (fname, ftype, fid) = iprot.readFieldBegin()
8348 
      if ftype == TType.STOP:
8349 
        break
8350 
      if fid == 1:
8351 
        if ftype == TType.I64:
1996 vikas 8352 
          self.id = iprot.readI64();
1845 vikas 8353 
        else:
8354 
          iprot.skip(ftype)
8355 
      else:
8356 
        iprot.skip(ftype)
8357 
      iprot.readFieldEnd()
8358 
    iprot.readStructEnd()
8359 
 
8360 
  def write(self, oprot):
8361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8363 
      return
1996 vikas 8364 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8365 
    if self.id != None:
8366 
      oprot.writeFieldBegin('id', TType.I64, 1)
8367 
      oprot.writeI64(self.id)
1845 vikas 8368 
      oprot.writeFieldEnd()
8369 
    oprot.writeFieldStop()
8370 
    oprot.writeStructEnd()
8371 
 
8372 
  def __repr__(self):
8373 
    L = ['%s=%r' % (key, value)
8374 
      for key, value in self.__dict__.iteritems()]
8375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8376 
 
8377 
  def __eq__(self, other):
8378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8379 
 
8380 
  def __ne__(self, other):
8381 
    return not (self == other)
8382 
 
1996 vikas 8383 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8384 
  """
8385 
  Attributes:
8386 
   - success
8387 
   - utx
8388 
  """
8389 
 
8390 
  thrift_spec = (
1996 vikas 8391 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8392 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8393 
  )
8394 
 
8395 
  def __init__(self, success=None, utx=None,):
8396 
    self.success = success
8397 
    self.utx = utx
8398 
 
8399 
  def read(self, iprot):
8400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8402 
      return
8403 
    iprot.readStructBegin()
8404 
    while True:
8405 
      (fname, ftype, fid) = iprot.readFieldBegin()
8406 
      if ftype == TType.STOP:
8407 
        break
8408 
      if fid == 0:
8409 
        if ftype == TType.LIST:
8410 
          self.success = []
2981 rajveer 8411 
          (_etype59, _size56) = iprot.readListBegin()
8412 
          for _i60 in xrange(_size56):
8413 
            _elem61 = Affiliate()
8414 
            _elem61.read(iprot)
8415 
            self.success.append(_elem61)
1845 vikas 8416 
          iprot.readListEnd()
8417 
        else:
8418 
          iprot.skip(ftype)
8419 
      elif fid == 1:
8420 
        if ftype == TType.STRUCT:
1996 vikas 8421 
          self.utx = UserAffiliateException()
1845 vikas 8422 
          self.utx.read(iprot)
8423 
        else:
8424 
          iprot.skip(ftype)
8425 
      else:
8426 
        iprot.skip(ftype)
8427 
      iprot.readFieldEnd()
8428 
    iprot.readStructEnd()
8429 
 
8430 
  def write(self, oprot):
8431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8433 
      return
1996 vikas 8434 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8435 
    if self.success != None:
8436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8438 
      for iter62 in self.success:
8439 
        iter62.write(oprot)
1845 vikas 8440 
      oprot.writeListEnd()
8441 
      oprot.writeFieldEnd()
8442 
    if self.utx != None:
8443 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8444 
      self.utx.write(oprot)
8445 
      oprot.writeFieldEnd()
8446 
    oprot.writeFieldStop()
8447 
    oprot.writeStructEnd()
8448 
 
8449 
  def __repr__(self):
8450 
    L = ['%s=%r' % (key, value)
8451 
      for key, value in self.__dict__.iteritems()]
8452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8453 
 
8454 
  def __eq__(self, other):
8455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8456 
 
8457 
  def __ne__(self, other):
8458 
    return not (self == other)
8459 
 
8460 
class addTrackLog_args:
8461 
  """
8462 
  Attributes:
1996 vikas 8463 
   - affiliateId
1845 vikas 8464 
   - userId
8465 
   - event
8466 
   - url
8467 
   - data
1859 vikas 8468 
   - addedOn
1845 vikas 8469 
  """
8470 
 
8471 
  thrift_spec = (
8472 
    None, # 0
1996 vikas 8473 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8474 
    (2, TType.I64, 'userId', None, None, ), # 2
8475 
    (3, TType.STRING, 'event', None, None, ), # 3
8476 
    (4, TType.STRING, 'url', None, None, ), # 4
8477 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8478 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8479 
  )
8480 
 
1996 vikas 8481 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8482 
    self.affiliateId = affiliateId
1845 vikas 8483 
    self.userId = userId
8484 
    self.event = event
8485 
    self.url = url
8486 
    self.data = data
1859 vikas 8487 
    self.addedOn = addedOn
1845 vikas 8488 
 
8489 
  def read(self, iprot):
8490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8492 
      return
8493 
    iprot.readStructBegin()
8494 
    while True:
8495 
      (fname, ftype, fid) = iprot.readFieldBegin()
8496 
      if ftype == TType.STOP:
8497 
        break
8498 
      if fid == 1:
8499 
        if ftype == TType.I64:
1996 vikas 8500 
          self.affiliateId = iprot.readI64();
1845 vikas 8501 
        else:
8502 
          iprot.skip(ftype)
8503 
      elif fid == 2:
8504 
        if ftype == TType.I64:
8505 
          self.userId = iprot.readI64();
8506 
        else:
8507 
          iprot.skip(ftype)
8508 
      elif fid == 3:
8509 
        if ftype == TType.STRING:
8510 
          self.event = iprot.readString();
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 4:
8514 
        if ftype == TType.STRING:
8515 
          self.url = iprot.readString();
8516 
        else:
8517 
          iprot.skip(ftype)
8518 
      elif fid == 5:
8519 
        if ftype == TType.STRING:
8520 
          self.data = iprot.readString();
8521 
        else:
8522 
          iprot.skip(ftype)
1859 vikas 8523 
      elif fid == 6:
8524 
        if ftype == TType.I64:
8525 
          self.addedOn = iprot.readI64();
8526 
        else:
8527 
          iprot.skip(ftype)
1845 vikas 8528 
      else:
8529 
        iprot.skip(ftype)
8530 
      iprot.readFieldEnd()
8531 
    iprot.readStructEnd()
8532 
 
8533 
  def write(self, oprot):
8534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8536 
      return
8537 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8538 
    if self.affiliateId != None:
8539 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8540 
      oprot.writeI64(self.affiliateId)
1845 vikas 8541 
      oprot.writeFieldEnd()
8542 
    if self.userId != None:
8543 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8544 
      oprot.writeI64(self.userId)
8545 
      oprot.writeFieldEnd()
8546 
    if self.event != None:
8547 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8548 
      oprot.writeString(self.event)
8549 
      oprot.writeFieldEnd()
8550 
    if self.url != None:
8551 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8552 
      oprot.writeString(self.url)
8553 
      oprot.writeFieldEnd()
8554 
    if self.data != None:
8555 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8556 
      oprot.writeString(self.data)
8557 
      oprot.writeFieldEnd()
1859 vikas 8558 
    if self.addedOn != None:
8559 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8560 
      oprot.writeI64(self.addedOn)
8561 
      oprot.writeFieldEnd()
1845 vikas 8562 
    oprot.writeFieldStop()
8563 
    oprot.writeStructEnd()
8564 
 
8565 
  def __repr__(self):
8566 
    L = ['%s=%r' % (key, value)
8567 
      for key, value in self.__dict__.iteritems()]
8568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8569 
 
8570 
  def __eq__(self, other):
8571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8572 
 
8573 
  def __ne__(self, other):
8574 
    return not (self == other)
8575 
 
8576 
class addTrackLog_result:
8577 
  """
8578 
  Attributes:
8579 
   - success
8580 
   - utx
8581 
  """
8582 
 
8583 
  thrift_spec = (
8584 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8585 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8586 
  )
8587 
 
8588 
  def __init__(self, success=None, utx=None,):
8589 
    self.success = success
8590 
    self.utx = utx
8591 
 
8592 
  def read(self, iprot):
8593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8595 
      return
8596 
    iprot.readStructBegin()
8597 
    while True:
8598 
      (fname, ftype, fid) = iprot.readFieldBegin()
8599 
      if ftype == TType.STOP:
8600 
        break
8601 
      if fid == 0:
8602 
        if ftype == TType.I64:
8603 
          self.success = iprot.readI64();
8604 
        else:
8605 
          iprot.skip(ftype)
8606 
      elif fid == 1:
8607 
        if ftype == TType.STRUCT:
1996 vikas 8608 
          self.utx = UserAffiliateException()
1845 vikas 8609 
          self.utx.read(iprot)
8610 
        else:
8611 
          iprot.skip(ftype)
8612 
      else:
8613 
        iprot.skip(ftype)
8614 
      iprot.readFieldEnd()
8615 
    iprot.readStructEnd()
8616 
 
8617 
  def write(self, oprot):
8618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8620 
      return
8621 
    oprot.writeStructBegin('addTrackLog_result')
8622 
    if self.success != None:
8623 
      oprot.writeFieldBegin('success', TType.I64, 0)
8624 
      oprot.writeI64(self.success)
8625 
      oprot.writeFieldEnd()
8626 
    if self.utx != None:
8627 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8628 
      self.utx.write(oprot)
8629 
      oprot.writeFieldEnd()
8630 
    oprot.writeFieldStop()
8631 
    oprot.writeStructEnd()
8632 
 
8633 
  def __repr__(self):
8634 
    L = ['%s=%r' % (key, value)
8635 
      for key, value in self.__dict__.iteritems()]
8636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8637 
 
8638 
  def __eq__(self, other):
8639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8640 
 
8641 
  def __ne__(self, other):
8642 
    return not (self == other)
8643 
 
8644 
class getTrackLogById_args:
8645 
  """
8646 
  Attributes:
8647 
   - id
8648 
  """
8649 
 
8650 
  thrift_spec = (
8651 
    None, # 0
8652 
    (1, TType.I64, 'id', None, None, ), # 1
8653 
  )
8654 
 
8655 
  def __init__(self, id=None,):
8656 
    self.id = id
8657 
 
8658 
  def read(self, iprot):
8659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8661 
      return
8662 
    iprot.readStructBegin()
8663 
    while True:
8664 
      (fname, ftype, fid) = iprot.readFieldBegin()
8665 
      if ftype == TType.STOP:
8666 
        break
8667 
      if fid == 1:
8668 
        if ftype == TType.I64:
8669 
          self.id = iprot.readI64();
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      else:
8673 
        iprot.skip(ftype)
8674 
      iprot.readFieldEnd()
8675 
    iprot.readStructEnd()
8676 
 
8677 
  def write(self, oprot):
8678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8680 
      return
8681 
    oprot.writeStructBegin('getTrackLogById_args')
8682 
    if self.id != None:
8683 
      oprot.writeFieldBegin('id', TType.I64, 1)
8684 
      oprot.writeI64(self.id)
8685 
      oprot.writeFieldEnd()
8686 
    oprot.writeFieldStop()
8687 
    oprot.writeStructEnd()
8688 
 
8689 
  def __repr__(self):
8690 
    L = ['%s=%r' % (key, value)
8691 
      for key, value in self.__dict__.iteritems()]
8692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8693 
 
8694 
  def __eq__(self, other):
8695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8696 
 
8697 
  def __ne__(self, other):
8698 
    return not (self == other)
8699 
 
8700 
class getTrackLogById_result:
8701 
  """
8702 
  Attributes:
8703 
   - success
8704 
   - utx
8705 
  """
8706 
 
8707 
  thrift_spec = (
8708 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8709 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8710 
  )
8711 
 
8712 
  def __init__(self, success=None, utx=None,):
8713 
    self.success = success
8714 
    self.utx = utx
8715 
 
8716 
  def read(self, iprot):
8717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8719 
      return
8720 
    iprot.readStructBegin()
8721 
    while True:
8722 
      (fname, ftype, fid) = iprot.readFieldBegin()
8723 
      if ftype == TType.STOP:
8724 
        break
8725 
      if fid == 0:
8726 
        if ftype == TType.STRUCT:
8727 
          self.success = TrackLog()
8728 
          self.success.read(iprot)
8729 
        else:
8730 
          iprot.skip(ftype)
8731 
      elif fid == 1:
8732 
        if ftype == TType.STRUCT:
1996 vikas 8733 
          self.utx = UserAffiliateException()
1845 vikas 8734 
          self.utx.read(iprot)
8735 
        else:
8736 
          iprot.skip(ftype)
8737 
      else:
8738 
        iprot.skip(ftype)
8739 
      iprot.readFieldEnd()
8740 
    iprot.readStructEnd()
8741 
 
8742 
  def write(self, oprot):
8743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8745 
      return
8746 
    oprot.writeStructBegin('getTrackLogById_result')
8747 
    if self.success != None:
8748 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8749 
      self.success.write(oprot)
8750 
      oprot.writeFieldEnd()
8751 
    if self.utx != None:
8752 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8753 
      self.utx.write(oprot)
8754 
      oprot.writeFieldEnd()
8755 
    oprot.writeFieldStop()
8756 
    oprot.writeStructEnd()
8757 
 
8758 
  def __repr__(self):
8759 
    L = ['%s=%r' % (key, value)
8760 
      for key, value in self.__dict__.iteritems()]
8761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8762 
 
8763 
  def __eq__(self, other):
8764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8765 
 
8766 
  def __ne__(self, other):
8767 
    return not (self == other)
8768 
 
1996 vikas 8769 
class getTrackLogsByAffiliate_args:
1845 vikas 8770 
  """
8771 
  Attributes:
1996 vikas 8772 
   - affiliateId
1845 vikas 8773 
  """
8774 
 
8775 
  thrift_spec = (
8776 
    None, # 0
1996 vikas 8777 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8778 
  )
8779 
 
1996 vikas 8780 
  def __init__(self, affiliateId=None,):
8781 
    self.affiliateId = affiliateId
1845 vikas 8782 
 
8783 
  def read(self, iprot):
8784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8786 
      return
8787 
    iprot.readStructBegin()
8788 
    while True:
8789 
      (fname, ftype, fid) = iprot.readFieldBegin()
8790 
      if ftype == TType.STOP:
8791 
        break
8792 
      if fid == 1:
8793 
        if ftype == TType.I64:
1996 vikas 8794 
          self.affiliateId = iprot.readI64();
1845 vikas 8795 
        else:
8796 
          iprot.skip(ftype)
8797 
      else:
8798 
        iprot.skip(ftype)
8799 
      iprot.readFieldEnd()
8800 
    iprot.readStructEnd()
8801 
 
8802 
  def write(self, oprot):
8803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8805 
      return
1996 vikas 8806 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8807 
    if self.affiliateId != None:
8808 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8809 
      oprot.writeI64(self.affiliateId)
1845 vikas 8810 
      oprot.writeFieldEnd()
8811 
    oprot.writeFieldStop()
8812 
    oprot.writeStructEnd()
8813 
 
8814 
  def __repr__(self):
8815 
    L = ['%s=%r' % (key, value)
8816 
      for key, value in self.__dict__.iteritems()]
8817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8818 
 
8819 
  def __eq__(self, other):
8820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8821 
 
8822 
  def __ne__(self, other):
8823 
    return not (self == other)
8824 
 
1996 vikas 8825 
class getTrackLogsByAffiliate_result:
1845 vikas 8826 
  """
8827 
  Attributes:
8828 
   - success
8829 
   - utx
8830 
  """
8831 
 
8832 
  thrift_spec = (
8833 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8834 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8835 
  )
8836 
 
8837 
  def __init__(self, success=None, utx=None,):
8838 
    self.success = success
8839 
    self.utx = utx
8840 
 
8841 
  def read(self, iprot):
8842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8844 
      return
8845 
    iprot.readStructBegin()
8846 
    while True:
8847 
      (fname, ftype, fid) = iprot.readFieldBegin()
8848 
      if ftype == TType.STOP:
8849 
        break
8850 
      if fid == 0:
8851 
        if ftype == TType.LIST:
8852 
          self.success = []
2981 rajveer 8853 
          (_etype66, _size63) = iprot.readListBegin()
8854 
          for _i67 in xrange(_size63):
8855 
            _elem68 = TrackLog()
8856 
            _elem68.read(iprot)
8857 
            self.success.append(_elem68)
1845 vikas 8858 
          iprot.readListEnd()
8859 
        else:
8860 
          iprot.skip(ftype)
8861 
      elif fid == 1:
8862 
        if ftype == TType.STRUCT:
1996 vikas 8863 
          self.utx = UserAffiliateException()
1845 vikas 8864 
          self.utx.read(iprot)
8865 
        else:
8866 
          iprot.skip(ftype)
8867 
      else:
8868 
        iprot.skip(ftype)
8869 
      iprot.readFieldEnd()
8870 
    iprot.readStructEnd()
8871 
 
8872 
  def write(self, oprot):
8873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8875 
      return
1996 vikas 8876 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8877 
    if self.success != None:
8878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8879 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8880 
      for iter69 in self.success:
8881 
        iter69.write(oprot)
1845 vikas 8882 
      oprot.writeListEnd()
8883 
      oprot.writeFieldEnd()
8884 
    if self.utx != None:
8885 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8886 
      self.utx.write(oprot)
8887 
      oprot.writeFieldEnd()
8888 
    oprot.writeFieldStop()
8889 
    oprot.writeStructEnd()
8890 
 
8891 
  def __repr__(self):
8892 
    L = ['%s=%r' % (key, value)
8893 
      for key, value in self.__dict__.iteritems()]
8894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8895 
 
8896 
  def __eq__(self, other):
8897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8898 
 
8899 
  def __ne__(self, other):
8900 
    return not (self == other)
8901 
 
8902 
class getTrackLogsByUser_args:
8903 
  """
8904 
  Attributes:
8905 
   - userId
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    None, # 0
8910 
    (1, TType.I64, 'userId', None, None, ), # 1
8911 
  )
8912 
 
8913 
  def __init__(self, userId=None,):
8914 
    self.userId = userId
8915 
 
8916 
  def read(self, iprot):
8917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8919 
      return
8920 
    iprot.readStructBegin()
8921 
    while True:
8922 
      (fname, ftype, fid) = iprot.readFieldBegin()
8923 
      if ftype == TType.STOP:
8924 
        break
8925 
      if fid == 1:
8926 
        if ftype == TType.I64:
8927 
          self.userId = iprot.readI64();
8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      else:
8931 
        iprot.skip(ftype)
8932 
      iprot.readFieldEnd()
8933 
    iprot.readStructEnd()
8934 
 
8935 
  def write(self, oprot):
8936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8938 
      return
8939 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8940 
    if self.userId != None:
8941 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8942 
      oprot.writeI64(self.userId)
8943 
      oprot.writeFieldEnd()
8944 
    oprot.writeFieldStop()
8945 
    oprot.writeStructEnd()
8946 
 
8947 
  def __repr__(self):
8948 
    L = ['%s=%r' % (key, value)
8949 
      for key, value in self.__dict__.iteritems()]
8950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8951 
 
8952 
  def __eq__(self, other):
8953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8954 
 
8955 
  def __ne__(self, other):
8956 
    return not (self == other)
8957 
 
8958 
class getTrackLogsByUser_result:
8959 
  """
8960 
  Attributes:
8961 
   - success
8962 
   - utx
8963 
  """
8964 
 
8965 
  thrift_spec = (
8966 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8967 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8968 
  )
8969 
 
8970 
  def __init__(self, success=None, utx=None,):
8971 
    self.success = success
8972 
    self.utx = utx
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 0:
8984 
        if ftype == TType.LIST:
8985 
          self.success = []
2981 rajveer 8986 
          (_etype73, _size70) = iprot.readListBegin()
8987 
          for _i74 in xrange(_size70):
8988 
            _elem75 = TrackLog()
8989 
            _elem75.read(iprot)
8990 
            self.success.append(_elem75)
1845 vikas 8991 
          iprot.readListEnd()
8992 
        else:
8993 
          iprot.skip(ftype)
8994 
      elif fid == 1:
8995 
        if ftype == TType.STRUCT:
1996 vikas 8996 
          self.utx = UserAffiliateException()
1845 vikas 8997 
          self.utx.read(iprot)
8998 
        else:
8999 
          iprot.skip(ftype)
9000 
      else:
9001 
        iprot.skip(ftype)
9002 
      iprot.readFieldEnd()
9003 
    iprot.readStructEnd()
9004 
 
9005 
  def write(self, oprot):
9006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9008 
      return
9009 
    oprot.writeStructBegin('getTrackLogsByUser_result')
9010 
    if self.success != None:
9011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9012 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9013 
      for iter76 in self.success:
9014 
        iter76.write(oprot)
1845 vikas 9015 
      oprot.writeListEnd()
9016 
      oprot.writeFieldEnd()
9017 
    if self.utx != None:
9018 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9019 
      self.utx.write(oprot)
9020 
      oprot.writeFieldEnd()
9021 
    oprot.writeFieldStop()
9022 
    oprot.writeStructEnd()
9023 
 
9024 
  def __repr__(self):
9025 
    L = ['%s=%r' % (key, value)
9026 
      for key, value in self.__dict__.iteritems()]
9027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9028 
 
9029 
  def __eq__(self, other):
9030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9031 
 
9032 
  def __ne__(self, other):
9033 
    return not (self == other)
9034 
 
9035 
class getTrackLogs_args:
9036 
  """
9037 
  Attributes:
9038 
   - userId
9039 
   - event
9040 
   - url
9041 
  """
9042 
 
9043 
  thrift_spec = (
9044 
    None, # 0
1996 vikas 9045 
    (1, TType.I64, 'userId', None, None, ), # 1
9046 
    (2, TType.STRING, 'event', None, None, ), # 2
9047 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9048 
  )
9049 
 
1996 vikas 9050 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9051 
    self.userId = userId
9052 
    self.event = event
9053 
    self.url = url
9054 
 
9055 
  def read(self, iprot):
9056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9058 
      return
9059 
    iprot.readStructBegin()
9060 
    while True:
9061 
      (fname, ftype, fid) = iprot.readFieldBegin()
9062 
      if ftype == TType.STOP:
9063 
        break
9064 
      if fid == 1:
9065 
        if ftype == TType.I64:
1996 vikas 9066 
          self.userId = iprot.readI64();
1845 vikas 9067 
        else:
9068 
          iprot.skip(ftype)
9069 
      elif fid == 2:
9070 
        if ftype == TType.STRING:
9071 
          self.event = iprot.readString();
9072 
        else:
9073 
          iprot.skip(ftype)
1996 vikas 9074 
      elif fid == 3:
1845 vikas 9075 
        if ftype == TType.STRING:
9076 
          self.url = iprot.readString();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      else:
9080 
        iprot.skip(ftype)
9081 
      iprot.readFieldEnd()
9082 
    iprot.readStructEnd()
9083 
 
9084 
  def write(self, oprot):
9085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9087 
      return
9088 
    oprot.writeStructBegin('getTrackLogs_args')
9089 
    if self.userId != None:
1996 vikas 9090 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9091 
      oprot.writeI64(self.userId)
9092 
      oprot.writeFieldEnd()
9093 
    if self.event != None:
1996 vikas 9094 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9095 
      oprot.writeString(self.event)
9096 
      oprot.writeFieldEnd()
9097 
    if self.url != None:
1996 vikas 9098 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9099 
      oprot.writeString(self.url)
9100 
      oprot.writeFieldEnd()
9101 
    oprot.writeFieldStop()
9102 
    oprot.writeStructEnd()
9103 
 
9104 
  def __repr__(self):
9105 
    L = ['%s=%r' % (key, value)
9106 
      for key, value in self.__dict__.iteritems()]
9107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9108 
 
9109 
  def __eq__(self, other):
9110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9111 
 
9112 
  def __ne__(self, other):
9113 
    return not (self == other)
9114 
 
9115 
class getTrackLogs_result:
9116 
  """
9117 
  Attributes:
9118 
   - success
9119 
   - utx
9120 
  """
9121 
 
9122 
  thrift_spec = (
9123 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9124 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9125 
  )
9126 
 
9127 
  def __init__(self, success=None, utx=None,):
9128 
    self.success = success
9129 
    self.utx = utx
9130 
 
9131 
  def read(self, iprot):
9132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9134 
      return
9135 
    iprot.readStructBegin()
9136 
    while True:
9137 
      (fname, ftype, fid) = iprot.readFieldBegin()
9138 
      if ftype == TType.STOP:
9139 
        break
9140 
      if fid == 0:
9141 
        if ftype == TType.LIST:
9142 
          self.success = []
2981 rajveer 9143 
          (_etype80, _size77) = iprot.readListBegin()
9144 
          for _i81 in xrange(_size77):
9145 
            _elem82 = TrackLog()
9146 
            _elem82.read(iprot)
9147 
            self.success.append(_elem82)
1845 vikas 9148 
          iprot.readListEnd()
9149 
        else:
9150 
          iprot.skip(ftype)
9151 
      elif fid == 1:
9152 
        if ftype == TType.STRUCT:
1996 vikas 9153 
          self.utx = UserAffiliateException()
1845 vikas 9154 
          self.utx.read(iprot)
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      else:
9158 
        iprot.skip(ftype)
9159 
      iprot.readFieldEnd()
9160 
    iprot.readStructEnd()
9161 
 
9162 
  def write(self, oprot):
9163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9165 
      return
9166 
    oprot.writeStructBegin('getTrackLogs_result')
9167 
    if self.success != None:
9168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9170 
      for iter83 in self.success:
9171 
        iter83.write(oprot)
1845 vikas 9172 
      oprot.writeListEnd()
9173 
      oprot.writeFieldEnd()
9174 
    if self.utx != None:
9175 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9176 
      self.utx.write(oprot)
9177 
      oprot.writeFieldEnd()
9178 
    oprot.writeFieldStop()
9179 
    oprot.writeStructEnd()
9180 
 
9181 
  def __repr__(self):
9182 
    L = ['%s=%r' % (key, value)
9183 
      for key, value in self.__dict__.iteritems()]
9184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9185 
 
9186 
  def __eq__(self, other):
9187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9188 
 
9189 
  def __ne__(self, other):
9190 
    return not (self == other)
9191 
 
559 chandransh 9192 
class createCart_args:
94 ashish 9193 
  """
9194 
  Attributes:
559 chandransh 9195 
   - userId
94 ashish 9196 
  """
9197 
 
9198 
  thrift_spec = (
9199 
    None, # 0
559 chandransh 9200 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9201 
  )
9202 
 
559 chandransh 9203 
  def __init__(self, userId=None,):
9204 
    self.userId = userId
94 ashish 9205 
 
9206 
  def read(self, iprot):
9207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9209 
      return
9210 
    iprot.readStructBegin()
9211 
    while True:
9212 
      (fname, ftype, fid) = iprot.readFieldBegin()
9213 
      if ftype == TType.STOP:
9214 
        break
9215 
      if fid == 1:
9216 
        if ftype == TType.I64:
559 chandransh 9217 
          self.userId = iprot.readI64();
94 ashish 9218 
        else:
9219 
          iprot.skip(ftype)
559 chandransh 9220 
      else:
9221 
        iprot.skip(ftype)
9222 
      iprot.readFieldEnd()
9223 
    iprot.readStructEnd()
9224 
 
9225 
  def write(self, oprot):
9226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9228 
      return
9229 
    oprot.writeStructBegin('createCart_args')
9230 
    if self.userId != None:
9231 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9232 
      oprot.writeI64(self.userId)
9233 
      oprot.writeFieldEnd()
9234 
    oprot.writeFieldStop()
9235 
    oprot.writeStructEnd()
9236 
 
9237 
  def __repr__(self):
9238 
    L = ['%s=%r' % (key, value)
9239 
      for key, value in self.__dict__.iteritems()]
9240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9241 
 
9242 
  def __eq__(self, other):
9243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9244 
 
9245 
  def __ne__(self, other):
9246 
    return not (self == other)
9247 
 
9248 
class createCart_result:
9249 
  """
9250 
  Attributes:
9251 
   - success
9252 
   - scx
9253 
  """
9254 
 
9255 
  thrift_spec = (
9256 
    (0, TType.I64, 'success', None, None, ), # 0
9257 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9258 
  )
9259 
 
9260 
  def __init__(self, success=None, scx=None,):
9261 
    self.success = success
9262 
    self.scx = scx
9263 
 
9264 
  def read(self, iprot):
9265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9267 
      return
9268 
    iprot.readStructBegin()
9269 
    while True:
9270 
      (fname, ftype, fid) = iprot.readFieldBegin()
9271 
      if ftype == TType.STOP:
9272 
        break
9273 
      if fid == 0:
94 ashish 9274 
        if ftype == TType.I64:
559 chandransh 9275 
          self.success = iprot.readI64();
94 ashish 9276 
        else:
9277 
          iprot.skip(ftype)
559 chandransh 9278 
      elif fid == 1:
9279 
        if ftype == TType.STRUCT:
9280 
          self.scx = ShoppingCartException()
9281 
          self.scx.read(iprot)
9282 
        else:
9283 
          iprot.skip(ftype)
94 ashish 9284 
      else:
9285 
        iprot.skip(ftype)
9286 
      iprot.readFieldEnd()
9287 
    iprot.readStructEnd()
9288 
 
9289 
  def write(self, oprot):
9290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9292 
      return
559 chandransh 9293 
    oprot.writeStructBegin('createCart_result')
9294 
    if self.success != None:
9295 
      oprot.writeFieldBegin('success', TType.I64, 0)
9296 
      oprot.writeI64(self.success)
94 ashish 9297 
      oprot.writeFieldEnd()
559 chandransh 9298 
    if self.scx != None:
9299 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9300 
      self.scx.write(oprot)
94 ashish 9301 
      oprot.writeFieldEnd()
9302 
    oprot.writeFieldStop()
9303 
    oprot.writeStructEnd()
9304 
 
9305 
  def __repr__(self):
9306 
    L = ['%s=%r' % (key, value)
9307 
      for key, value in self.__dict__.iteritems()]
9308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9309 
 
9310 
  def __eq__(self, other):
9311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9312 
 
9313 
  def __ne__(self, other):
9314 
    return not (self == other)
9315 
 
559 chandransh 9316 
class getCurrentCart_args:
94 ashish 9317 
  """
9318 
  Attributes:
559 chandransh 9319 
   - userId
9320 
  """
9321 
 
9322 
  thrift_spec = (
9323 
    None, # 0
9324 
    (1, TType.I64, 'userId', None, None, ), # 1
9325 
  )
9326 
 
9327 
  def __init__(self, userId=None,):
9328 
    self.userId = userId
9329 
 
9330 
  def read(self, iprot):
9331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9333 
      return
9334 
    iprot.readStructBegin()
9335 
    while True:
9336 
      (fname, ftype, fid) = iprot.readFieldBegin()
9337 
      if ftype == TType.STOP:
9338 
        break
9339 
      if fid == 1:
9340 
        if ftype == TType.I64:
9341 
          self.userId = iprot.readI64();
9342 
        else:
9343 
          iprot.skip(ftype)
9344 
      else:
9345 
        iprot.skip(ftype)
9346 
      iprot.readFieldEnd()
9347 
    iprot.readStructEnd()
9348 
 
9349 
  def write(self, oprot):
9350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9352 
      return
9353 
    oprot.writeStructBegin('getCurrentCart_args')
9354 
    if self.userId != None:
9355 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9356 
      oprot.writeI64(self.userId)
9357 
      oprot.writeFieldEnd()
9358 
    oprot.writeFieldStop()
9359 
    oprot.writeStructEnd()
9360 
 
9361 
  def __repr__(self):
9362 
    L = ['%s=%r' % (key, value)
9363 
      for key, value in self.__dict__.iteritems()]
9364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9365 
 
9366 
  def __eq__(self, other):
9367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9368 
 
9369 
  def __ne__(self, other):
9370 
    return not (self == other)
9371 
 
9372 
class getCurrentCart_result:
9373 
  """
9374 
  Attributes:
94 ashish 9375 
   - success
559 chandransh 9376 
   - scx
94 ashish 9377 
  """
9378 
 
9379 
  thrift_spec = (
559 chandransh 9380 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9381 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9382 
  )
9383 
 
559 chandransh 9384 
  def __init__(self, success=None, scx=None,):
94 ashish 9385 
    self.success = success
559 chandransh 9386 
    self.scx = scx
94 ashish 9387 
 
9388 
  def read(self, iprot):
9389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9391 
      return
9392 
    iprot.readStructBegin()
9393 
    while True:
9394 
      (fname, ftype, fid) = iprot.readFieldBegin()
9395 
      if ftype == TType.STOP:
9396 
        break
9397 
      if fid == 0:
559 chandransh 9398 
        if ftype == TType.STRUCT:
9399 
          self.success = Cart()
9400 
          self.success.read(iprot)
94 ashish 9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      elif fid == 1:
9404 
        if ftype == TType.STRUCT:
559 chandransh 9405 
          self.scx = ShoppingCartException()
9406 
          self.scx.read(iprot)
94 ashish 9407 
        else:
9408 
          iprot.skip(ftype)
9409 
      else:
9410 
        iprot.skip(ftype)
9411 
      iprot.readFieldEnd()
9412 
    iprot.readStructEnd()
9413 
 
9414 
  def write(self, oprot):
9415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9417 
      return
559 chandransh 9418 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9419 
    if self.success != None:
559 chandransh 9420 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9421 
      self.success.write(oprot)
94 ashish 9422 
      oprot.writeFieldEnd()
559 chandransh 9423 
    if self.scx != None:
9424 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9425 
      self.scx.write(oprot)
94 ashish 9426 
      oprot.writeFieldEnd()
9427 
    oprot.writeFieldStop()
9428 
    oprot.writeStructEnd()
9429 
 
9430 
  def __repr__(self):
9431 
    L = ['%s=%r' % (key, value)
9432 
      for key, value in self.__dict__.iteritems()]
9433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9434 
 
9435 
  def __eq__(self, other):
9436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9437 
 
9438 
  def __ne__(self, other):
9439 
    return not (self == other)
9440 
 
559 chandransh 9441 
class getCart_args:
504 rajveer 9442 
  """
9443 
  Attributes:
559 chandransh 9444 
   - cartId
504 rajveer 9445 
  """
9446 
 
9447 
  thrift_spec = (
9448 
    None, # 0
559 chandransh 9449 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9450 
  )
9451 
 
559 chandransh 9452 
  def __init__(self, cartId=None,):
9453 
    self.cartId = cartId
504 rajveer 9454 
 
9455 
  def read(self, iprot):
9456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9458 
      return
9459 
    iprot.readStructBegin()
9460 
    while True:
9461 
      (fname, ftype, fid) = iprot.readFieldBegin()
9462 
      if ftype == TType.STOP:
9463 
        break
9464 
      if fid == 1:
9465 
        if ftype == TType.I64:
559 chandransh 9466 
          self.cartId = iprot.readI64();
504 rajveer 9467 
        else:
9468 
          iprot.skip(ftype)
9469 
      else:
9470 
        iprot.skip(ftype)
9471 
      iprot.readFieldEnd()
9472 
    iprot.readStructEnd()
9473 
 
9474 
  def write(self, oprot):
9475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9477 
      return
559 chandransh 9478 
    oprot.writeStructBegin('getCart_args')
9479 
    if self.cartId != None:
9480 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9481 
      oprot.writeI64(self.cartId)
504 rajveer 9482 
      oprot.writeFieldEnd()
9483 
    oprot.writeFieldStop()
9484 
    oprot.writeStructEnd()
9485 
 
9486 
  def __repr__(self):
9487 
    L = ['%s=%r' % (key, value)
9488 
      for key, value in self.__dict__.iteritems()]
9489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9490 
 
9491 
  def __eq__(self, other):
9492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9493 
 
9494 
  def __ne__(self, other):
9495 
    return not (self == other)
9496 
 
559 chandransh 9497 
class getCart_result:
504 rajveer 9498 
  """
9499 
  Attributes:
9500 
   - success
559 chandransh 9501 
   - scx
504 rajveer 9502 
  """
9503 
 
9504 
  thrift_spec = (
559 chandransh 9505 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9506 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9507 
  )
9508 
 
559 chandransh 9509 
  def __init__(self, success=None, scx=None,):
504 rajveer 9510 
    self.success = success
559 chandransh 9511 
    self.scx = scx
504 rajveer 9512 
 
9513 
  def read(self, iprot):
9514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9516 
      return
9517 
    iprot.readStructBegin()
9518 
    while True:
9519 
      (fname, ftype, fid) = iprot.readFieldBegin()
9520 
      if ftype == TType.STOP:
9521 
        break
9522 
      if fid == 0:
559 chandransh 9523 
        if ftype == TType.STRUCT:
9524 
          self.success = Cart()
9525 
          self.success.read(iprot)
504 rajveer 9526 
        else:
9527 
          iprot.skip(ftype)
9528 
      elif fid == 1:
9529 
        if ftype == TType.STRUCT:
559 chandransh 9530 
          self.scx = ShoppingCartException()
9531 
          self.scx.read(iprot)
504 rajveer 9532 
        else:
9533 
          iprot.skip(ftype)
9534 
      else:
9535 
        iprot.skip(ftype)
9536 
      iprot.readFieldEnd()
9537 
    iprot.readStructEnd()
9538 
 
9539 
  def write(self, oprot):
9540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9542 
      return
559 chandransh 9543 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9544 
    if self.success != None:
559 chandransh 9545 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9546 
      self.success.write(oprot)
504 rajveer 9547 
      oprot.writeFieldEnd()
559 chandransh 9548 
    if self.scx != None:
9549 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9550 
      self.scx.write(oprot)
504 rajveer 9551 
      oprot.writeFieldEnd()
9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
9555 
  def __repr__(self):
9556 
    L = ['%s=%r' % (key, value)
9557 
      for key, value in self.__dict__.iteritems()]
9558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9559 
 
9560 
  def __eq__(self, other):
9561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9562 
 
9563 
  def __ne__(self, other):
9564 
    return not (self == other)
9565 
 
559 chandransh 9566 
class getCartsForUser_args:
94 ashish 9567 
  """
9568 
  Attributes:
559 chandransh 9569 
   - userId
9570 
   - status
94 ashish 9571 
  """
9572 
 
9573 
  thrift_spec = (
9574 
    None, # 0
559 chandransh 9575 
    (1, TType.I64, 'userId', None, None, ), # 1
9576 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9577 
  )
9578 
 
559 chandransh 9579 
  def __init__(self, userId=None, status=None,):
9580 
    self.userId = userId
9581 
    self.status = status
94 ashish 9582 
 
9583 
  def read(self, iprot):
9584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9586 
      return
9587 
    iprot.readStructBegin()
9588 
    while True:
9589 
      (fname, ftype, fid) = iprot.readFieldBegin()
9590 
      if ftype == TType.STOP:
9591 
        break
9592 
      if fid == 1:
9593 
        if ftype == TType.I64:
559 chandransh 9594 
          self.userId = iprot.readI64();
94 ashish 9595 
        else:
9596 
          iprot.skip(ftype)
9597 
      elif fid == 2:
559 chandransh 9598 
        if ftype == TType.I32:
9599 
          self.status = iprot.readI32();
94 ashish 9600 
        else:
9601 
          iprot.skip(ftype)
9602 
      else:
9603 
        iprot.skip(ftype)
9604 
      iprot.readFieldEnd()
9605 
    iprot.readStructEnd()
9606 
 
9607 
  def write(self, oprot):
9608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9610 
      return
559 chandransh 9611 
    oprot.writeStructBegin('getCartsForUser_args')
9612 
    if self.userId != None:
9613 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9614 
      oprot.writeI64(self.userId)
94 ashish 9615 
      oprot.writeFieldEnd()
559 chandransh 9616 
    if self.status != None:
9617 
      oprot.writeFieldBegin('status', TType.I32, 2)
9618 
      oprot.writeI32(self.status)
94 ashish 9619 
      oprot.writeFieldEnd()
9620 
    oprot.writeFieldStop()
9621 
    oprot.writeStructEnd()
9622 
 
9623 
  def __repr__(self):
9624 
    L = ['%s=%r' % (key, value)
9625 
      for key, value in self.__dict__.iteritems()]
9626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9627 
 
9628 
  def __eq__(self, other):
9629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9630 
 
9631 
  def __ne__(self, other):
9632 
    return not (self == other)
9633 
 
559 chandransh 9634 
class getCartsForUser_result:
94 ashish 9635 
  """
9636 
  Attributes:
9637 
   - success
559 chandransh 9638 
   - scx
94 ashish 9639 
  """
9640 
 
9641 
  thrift_spec = (
559 chandransh 9642 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9643 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9644 
  )
9645 
 
559 chandransh 9646 
  def __init__(self, success=None, scx=None,):
94 ashish 9647 
    self.success = success
559 chandransh 9648 
    self.scx = scx
94 ashish 9649 
 
9650 
  def read(self, iprot):
9651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9653 
      return
9654 
    iprot.readStructBegin()
9655 
    while True:
9656 
      (fname, ftype, fid) = iprot.readFieldBegin()
9657 
      if ftype == TType.STOP:
9658 
        break
9659 
      if fid == 0:
559 chandransh 9660 
        if ftype == TType.LIST:
9661 
          self.success = []
2981 rajveer 9662 
          (_etype87, _size84) = iprot.readListBegin()
9663 
          for _i88 in xrange(_size84):
9664 
            _elem89 = Cart()
9665 
            _elem89.read(iprot)
9666 
            self.success.append(_elem89)
559 chandransh 9667 
          iprot.readListEnd()
94 ashish 9668 
        else:
9669 
          iprot.skip(ftype)
9670 
      elif fid == 1:
9671 
        if ftype == TType.STRUCT:
559 chandransh 9672 
          self.scx = ShoppingCartException()
9673 
          self.scx.read(iprot)
94 ashish 9674 
        else:
9675 
          iprot.skip(ftype)
9676 
      else:
9677 
        iprot.skip(ftype)
9678 
      iprot.readFieldEnd()
9679 
    iprot.readStructEnd()
9680 
 
9681 
  def write(self, oprot):
9682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9684 
      return
559 chandransh 9685 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9686 
    if self.success != None:
559 chandransh 9687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9688 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9689 
      for iter90 in self.success:
9690 
        iter90.write(oprot)
559 chandransh 9691 
      oprot.writeListEnd()
94 ashish 9692 
      oprot.writeFieldEnd()
559 chandransh 9693 
    if self.scx != None:
9694 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9695 
      self.scx.write(oprot)
94 ashish 9696 
      oprot.writeFieldEnd()
9697 
    oprot.writeFieldStop()
9698 
    oprot.writeStructEnd()
9699 
 
9700 
  def __repr__(self):
9701 
    L = ['%s=%r' % (key, value)
9702 
      for key, value in self.__dict__.iteritems()]
9703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9704 
 
9705 
  def __eq__(self, other):
9706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9707 
 
9708 
  def __ne__(self, other):
9709 
    return not (self == other)
9710 
 
559 chandransh 9711 
class getCartsByStatus_args:
94 ashish 9712 
  """
9713 
  Attributes:
559 chandransh 9714 
   - status
94 ashish 9715 
  """
9716 
 
9717 
  thrift_spec = (
9718 
    None, # 0
559 chandransh 9719 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9720 
  )
9721 
 
559 chandransh 9722 
  def __init__(self, status=None,):
9723 
    self.status = status
94 ashish 9724 
 
9725 
  def read(self, iprot):
9726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9728 
      return
9729 
    iprot.readStructBegin()
9730 
    while True:
9731 
      (fname, ftype, fid) = iprot.readFieldBegin()
9732 
      if ftype == TType.STOP:
9733 
        break
9734 
      if fid == 1:
559 chandransh 9735 
        if ftype == TType.I32:
9736 
          self.status = iprot.readI32();
9737 
        else:
9738 
          iprot.skip(ftype)
9739 
      else:
9740 
        iprot.skip(ftype)
9741 
      iprot.readFieldEnd()
9742 
    iprot.readStructEnd()
9743 
 
9744 
  def write(self, oprot):
9745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9747 
      return
9748 
    oprot.writeStructBegin('getCartsByStatus_args')
9749 
    if self.status != None:
9750 
      oprot.writeFieldBegin('status', TType.I32, 1)
9751 
      oprot.writeI32(self.status)
9752 
      oprot.writeFieldEnd()
9753 
    oprot.writeFieldStop()
9754 
    oprot.writeStructEnd()
9755 
 
9756 
  def __repr__(self):
9757 
    L = ['%s=%r' % (key, value)
9758 
      for key, value in self.__dict__.iteritems()]
9759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9760 
 
9761 
  def __eq__(self, other):
9762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9763 
 
9764 
  def __ne__(self, other):
9765 
    return not (self == other)
9766 
 
9767 
class getCartsByStatus_result:
9768 
  """
9769 
  Attributes:
9770 
   - success
9771 
   - scx
9772 
  """
9773 
 
9774 
  thrift_spec = (
9775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9776 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9777 
  )
9778 
 
9779 
  def __init__(self, success=None, scx=None,):
9780 
    self.success = success
9781 
    self.scx = scx
9782 
 
9783 
  def read(self, iprot):
9784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9786 
      return
9787 
    iprot.readStructBegin()
9788 
    while True:
9789 
      (fname, ftype, fid) = iprot.readFieldBegin()
9790 
      if ftype == TType.STOP:
9791 
        break
9792 
      if fid == 0:
9793 
        if ftype == TType.LIST:
9794 
          self.success = []
2981 rajveer 9795 
          (_etype94, _size91) = iprot.readListBegin()
9796 
          for _i95 in xrange(_size91):
9797 
            _elem96 = Cart()
9798 
            _elem96.read(iprot)
9799 
            self.success.append(_elem96)
559 chandransh 9800 
          iprot.readListEnd()
9801 
        else:
9802 
          iprot.skip(ftype)
9803 
      elif fid == 1:
9804 
        if ftype == TType.STRUCT:
9805 
          self.scx = ShoppingCartException()
9806 
          self.scx.read(iprot)
9807 
        else:
9808 
          iprot.skip(ftype)
9809 
      else:
9810 
        iprot.skip(ftype)
9811 
      iprot.readFieldEnd()
9812 
    iprot.readStructEnd()
9813 
 
9814 
  def write(self, oprot):
9815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9817 
      return
9818 
    oprot.writeStructBegin('getCartsByStatus_result')
9819 
    if self.success != None:
9820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9822 
      for iter97 in self.success:
9823 
        iter97.write(oprot)
559 chandransh 9824 
      oprot.writeListEnd()
9825 
      oprot.writeFieldEnd()
9826 
    if self.scx != None:
9827 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9828 
      self.scx.write(oprot)
9829 
      oprot.writeFieldEnd()
9830 
    oprot.writeFieldStop()
9831 
    oprot.writeStructEnd()
9832 
 
9833 
  def __repr__(self):
9834 
    L = ['%s=%r' % (key, value)
9835 
      for key, value in self.__dict__.iteritems()]
9836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9837 
 
9838 
  def __eq__(self, other):
9839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9840 
 
9841 
  def __ne__(self, other):
9842 
    return not (self == other)
9843 
 
9844 
class getCartsByTime_args:
9845 
  """
9846 
  Attributes:
9847 
   - from_time
9848 
   - to_time
9849 
   - status
9850 
  """
9851 
 
9852 
  thrift_spec = (
9853 
    None, # 0
9854 
    (1, TType.I64, 'from_time', None, None, ), # 1
9855 
    (2, TType.I64, 'to_time', None, None, ), # 2
9856 
    (3, TType.I32, 'status', None, None, ), # 3
9857 
  )
9858 
 
9859 
  def __init__(self, from_time=None, to_time=None, status=None,):
9860 
    self.from_time = from_time
9861 
    self.to_time = to_time
9862 
    self.status = status
9863 
 
9864 
  def read(self, iprot):
9865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9867 
      return
9868 
    iprot.readStructBegin()
9869 
    while True:
9870 
      (fname, ftype, fid) = iprot.readFieldBegin()
9871 
      if ftype == TType.STOP:
9872 
        break
9873 
      if fid == 1:
94 ashish 9874 
        if ftype == TType.I64:
559 chandransh 9875 
          self.from_time = iprot.readI64();
94 ashish 9876 
        else:
9877 
          iprot.skip(ftype)
122 ashish 9878 
      elif fid == 2:
559 chandransh 9879 
        if ftype == TType.I64:
9880 
          self.to_time = iprot.readI64();
122 ashish 9881 
        else:
9882 
          iprot.skip(ftype)
559 chandransh 9883 
      elif fid == 3:
9884 
        if ftype == TType.I32:
9885 
          self.status = iprot.readI32();
9886 
        else:
9887 
          iprot.skip(ftype)
94 ashish 9888 
      else:
9889 
        iprot.skip(ftype)
9890 
      iprot.readFieldEnd()
9891 
    iprot.readStructEnd()
9892 
 
9893 
  def write(self, oprot):
9894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9896 
      return
559 chandransh 9897 
    oprot.writeStructBegin('getCartsByTime_args')
9898 
    if self.from_time != None:
9899 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9900 
      oprot.writeI64(self.from_time)
94 ashish 9901 
      oprot.writeFieldEnd()
559 chandransh 9902 
    if self.to_time != None:
9903 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9904 
      oprot.writeI64(self.to_time)
122 ashish 9905 
      oprot.writeFieldEnd()
559 chandransh 9906 
    if self.status != None:
9907 
      oprot.writeFieldBegin('status', TType.I32, 3)
9908 
      oprot.writeI32(self.status)
9909 
      oprot.writeFieldEnd()
94 ashish 9910 
    oprot.writeFieldStop()
9911 
    oprot.writeStructEnd()
9912 
 
9913 
  def __repr__(self):
9914 
    L = ['%s=%r' % (key, value)
9915 
      for key, value in self.__dict__.iteritems()]
9916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9917 
 
9918 
  def __eq__(self, other):
9919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9920 
 
9921 
  def __ne__(self, other):
9922 
    return not (self == other)
9923 
 
559 chandransh 9924 
class getCartsByTime_result:
94 ashish 9925 
  """
9926 
  Attributes:
9927 
   - success
559 chandransh 9928 
   - scx
94 ashish 9929 
  """
9930 
 
9931 
  thrift_spec = (
559 chandransh 9932 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9933 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9934 
  )
9935 
 
559 chandransh 9936 
  def __init__(self, success=None, scx=None,):
94 ashish 9937 
    self.success = success
559 chandransh 9938 
    self.scx = scx
94 ashish 9939 
 
9940 
  def read(self, iprot):
9941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9943 
      return
9944 
    iprot.readStructBegin()
9945 
    while True:
9946 
      (fname, ftype, fid) = iprot.readFieldBegin()
9947 
      if ftype == TType.STOP:
9948 
        break
9949 
      if fid == 0:
559 chandransh 9950 
        if ftype == TType.LIST:
9951 
          self.success = []
2981 rajveer 9952 
          (_etype101, _size98) = iprot.readListBegin()
9953 
          for _i102 in xrange(_size98):
9954 
            _elem103 = Cart()
9955 
            _elem103.read(iprot)
9956 
            self.success.append(_elem103)
559 chandransh 9957 
          iprot.readListEnd()
94 ashish 9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      elif fid == 1:
9961 
        if ftype == TType.STRUCT:
559 chandransh 9962 
          self.scx = ShoppingCartException()
9963 
          self.scx.read(iprot)
94 ashish 9964 
        else:
9965 
          iprot.skip(ftype)
9966 
      else:
9967 
        iprot.skip(ftype)
9968 
      iprot.readFieldEnd()
9969 
    iprot.readStructEnd()
9970 
 
9971 
  def write(self, oprot):
9972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9974 
      return
559 chandransh 9975 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9976 
    if self.success != None:
559 chandransh 9977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9978 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9979 
      for iter104 in self.success:
9980 
        iter104.write(oprot)
559 chandransh 9981 
      oprot.writeListEnd()
94 ashish 9982 
      oprot.writeFieldEnd()
559 chandransh 9983 
    if self.scx != None:
9984 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9985 
      self.scx.write(oprot)
94 ashish 9986 
      oprot.writeFieldEnd()
9987 
    oprot.writeFieldStop()
9988 
    oprot.writeStructEnd()
9989 
 
9990 
  def __repr__(self):
9991 
    L = ['%s=%r' % (key, value)
9992 
      for key, value in self.__dict__.iteritems()]
9993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9994 
 
9995 
  def __eq__(self, other):
9996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9997 
 
9998 
  def __ne__(self, other):
9999 
    return not (self == other)
10000 
 
559 chandransh 10001 
class changeCartStatus_args:
94 ashish 10002 
  """
10003 
  Attributes:
559 chandransh 10004 
   - cartId
10005 
   - status
94 ashish 10006 
  """
10007 
 
10008 
  thrift_spec = (
10009 
    None, # 0
559 chandransh 10010 
    (1, TType.I64, 'cartId', None, None, ), # 1
10011 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 10012 
  )
10013 
 
559 chandransh 10014 
  def __init__(self, cartId=None, status=None,):
10015 
    self.cartId = cartId
10016 
    self.status = status
94 ashish 10017 
 
10018 
  def read(self, iprot):
10019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10021 
      return
10022 
    iprot.readStructBegin()
10023 
    while True:
10024 
      (fname, ftype, fid) = iprot.readFieldBegin()
10025 
      if ftype == TType.STOP:
10026 
        break
10027 
      if fid == 1:
10028 
        if ftype == TType.I64:
559 chandransh 10029 
          self.cartId = iprot.readI64();
94 ashish 10030 
        else:
10031 
          iprot.skip(ftype)
559 chandransh 10032 
      elif fid == 2:
10033 
        if ftype == TType.I32:
10034 
          self.status = iprot.readI32();
10035 
        else:
10036 
          iprot.skip(ftype)
94 ashish 10037 
      else:
10038 
        iprot.skip(ftype)
10039 
      iprot.readFieldEnd()
10040 
    iprot.readStructEnd()
10041 
 
10042 
  def write(self, oprot):
10043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10045 
      return
559 chandransh 10046 
    oprot.writeStructBegin('changeCartStatus_args')
10047 
    if self.cartId != None:
10048 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10049 
      oprot.writeI64(self.cartId)
94 ashish 10050 
      oprot.writeFieldEnd()
559 chandransh 10051 
    if self.status != None:
10052 
      oprot.writeFieldBegin('status', TType.I32, 2)
10053 
      oprot.writeI32(self.status)
10054 
      oprot.writeFieldEnd()
94 ashish 10055 
    oprot.writeFieldStop()
10056 
    oprot.writeStructEnd()
10057 
 
10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
559 chandransh 10069 
class changeCartStatus_result:
94 ashish 10070 
  """
10071 
  Attributes:
559 chandransh 10072 
   - scx
10073 
  """
10074 
 
10075 
  thrift_spec = (
10076 
    None, # 0
10077 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10078 
  )
10079 
 
10080 
  def __init__(self, scx=None,):
10081 
    self.scx = scx
10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 1:
10093 
        if ftype == TType.STRUCT:
10094 
          self.scx = ShoppingCartException()
10095 
          self.scx.read(iprot)
10096 
        else:
10097 
          iprot.skip(ftype)
10098 
      else:
10099 
        iprot.skip(ftype)
10100 
      iprot.readFieldEnd()
10101 
    iprot.readStructEnd()
10102 
 
10103 
  def write(self, oprot):
10104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10106 
      return
10107 
    oprot.writeStructBegin('changeCartStatus_result')
10108 
    if self.scx != None:
10109 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10110 
      self.scx.write(oprot)
10111 
      oprot.writeFieldEnd()
10112 
    oprot.writeFieldStop()
10113 
    oprot.writeStructEnd()
10114 
 
10115 
  def __repr__(self):
10116 
    L = ['%s=%r' % (key, value)
10117 
      for key, value in self.__dict__.iteritems()]
10118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10119 
 
10120 
  def __eq__(self, other):
10121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10122 
 
10123 
  def __ne__(self, other):
10124 
    return not (self == other)
10125 
 
10126 
class addItemToCart_args:
10127 
  """
10128 
  Attributes:
10129 
   - cartId
10130 
   - itemId
10131 
   - quantity
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    None, # 0
10136 
    (1, TType.I64, 'cartId', None, None, ), # 1
10137 
    (2, TType.I64, 'itemId', None, None, ), # 2
10138 
    (3, TType.I64, 'quantity', None, None, ), # 3
10139 
  )
10140 
 
10141 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10142 
    self.cartId = cartId
10143 
    self.itemId = itemId
10144 
    self.quantity = quantity
10145 
 
10146 
  def read(self, iprot):
10147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10149 
      return
10150 
    iprot.readStructBegin()
10151 
    while True:
10152 
      (fname, ftype, fid) = iprot.readFieldBegin()
10153 
      if ftype == TType.STOP:
10154 
        break
10155 
      if fid == 1:
10156 
        if ftype == TType.I64:
10157 
          self.cartId = iprot.readI64();
10158 
        else:
10159 
          iprot.skip(ftype)
10160 
      elif fid == 2:
10161 
        if ftype == TType.I64:
10162 
          self.itemId = iprot.readI64();
10163 
        else:
10164 
          iprot.skip(ftype)
10165 
      elif fid == 3:
10166 
        if ftype == TType.I64:
10167 
          self.quantity = iprot.readI64();
10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      else:
10171 
        iprot.skip(ftype)
10172 
      iprot.readFieldEnd()
10173 
    iprot.readStructEnd()
10174 
 
10175 
  def write(self, oprot):
10176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10178 
      return
10179 
    oprot.writeStructBegin('addItemToCart_args')
10180 
    if self.cartId != None:
10181 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10182 
      oprot.writeI64(self.cartId)
10183 
      oprot.writeFieldEnd()
10184 
    if self.itemId != None:
10185 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10186 
      oprot.writeI64(self.itemId)
10187 
      oprot.writeFieldEnd()
10188 
    if self.quantity != None:
10189 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10190 
      oprot.writeI64(self.quantity)
10191 
      oprot.writeFieldEnd()
10192 
    oprot.writeFieldStop()
10193 
    oprot.writeStructEnd()
10194 
 
10195 
  def __repr__(self):
10196 
    L = ['%s=%r' % (key, value)
10197 
      for key, value in self.__dict__.iteritems()]
10198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10199 
 
10200 
  def __eq__(self, other):
10201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10202 
 
10203 
  def __ne__(self, other):
10204 
    return not (self == other)
10205 
 
10206 
class addItemToCart_result:
10207 
  """
10208 
  Attributes:
2035 rajveer 10209 
   - success
559 chandransh 10210 
   - scx
10211 
  """
10212 
 
10213 
  thrift_spec = (
2035 rajveer 10214 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10215 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10216 
  )
10217 
 
2035 rajveer 10218 
  def __init__(self, success=None, scx=None,):
10219 
    self.success = success
559 chandransh 10220 
    self.scx = scx
10221 
 
10222 
  def read(self, iprot):
10223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10225 
      return
10226 
    iprot.readStructBegin()
10227 
    while True:
10228 
      (fname, ftype, fid) = iprot.readFieldBegin()
10229 
      if ftype == TType.STOP:
10230 
        break
2035 rajveer 10231 
      if fid == 0:
10232 
        if ftype == TType.STRING:
10233 
          self.success = iprot.readString();
10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      elif fid == 1:
559 chandransh 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('addItemToCart_result')
2035 rajveer 10252 
    if self.success != None:
10253 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10254 
      oprot.writeString(self.success)
10255 
      oprot.writeFieldEnd()
559 chandransh 10256 
    if self.scx != None:
10257 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10258 
      self.scx.write(oprot)
10259 
      oprot.writeFieldEnd()
10260 
    oprot.writeFieldStop()
10261 
    oprot.writeStructEnd()
10262 
 
10263 
  def __repr__(self):
10264 
    L = ['%s=%r' % (key, value)
10265 
      for key, value in self.__dict__.iteritems()]
10266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10267 
 
10268 
  def __eq__(self, other):
10269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10270 
 
10271 
  def __ne__(self, other):
10272 
    return not (self == other)
10273 
 
10274 
class deleteItemFromCart_args:
10275 
  """
10276 
  Attributes:
10277 
   - cartId
10278 
   - itemId
10279 
  """
10280 
 
10281 
  thrift_spec = (
10282 
    None, # 0
10283 
    (1, TType.I64, 'cartId', None, None, ), # 1
10284 
    (2, TType.I64, 'itemId', None, None, ), # 2
10285 
  )
10286 
 
10287 
  def __init__(self, cartId=None, itemId=None,):
10288 
    self.cartId = cartId
10289 
    self.itemId = itemId
10290 
 
10291 
  def read(self, iprot):
10292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10294 
      return
10295 
    iprot.readStructBegin()
10296 
    while True:
10297 
      (fname, ftype, fid) = iprot.readFieldBegin()
10298 
      if ftype == TType.STOP:
10299 
        break
10300 
      if fid == 1:
10301 
        if ftype == TType.I64:
10302 
          self.cartId = iprot.readI64();
10303 
        else:
10304 
          iprot.skip(ftype)
10305 
      elif fid == 2:
10306 
        if ftype == TType.I64:
10307 
          self.itemId = iprot.readI64();
10308 
        else:
10309 
          iprot.skip(ftype)
10310 
      else:
10311 
        iprot.skip(ftype)
10312 
      iprot.readFieldEnd()
10313 
    iprot.readStructEnd()
10314 
 
10315 
  def write(self, oprot):
10316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10318 
      return
10319 
    oprot.writeStructBegin('deleteItemFromCart_args')
10320 
    if self.cartId != None:
10321 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10322 
      oprot.writeI64(self.cartId)
10323 
      oprot.writeFieldEnd()
10324 
    if self.itemId != None:
10325 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10326 
      oprot.writeI64(self.itemId)
10327 
      oprot.writeFieldEnd()
10328 
    oprot.writeFieldStop()
10329 
    oprot.writeStructEnd()
10330 
 
10331 
  def __repr__(self):
10332 
    L = ['%s=%r' % (key, value)
10333 
      for key, value in self.__dict__.iteritems()]
10334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10335 
 
10336 
  def __eq__(self, other):
10337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10338 
 
10339 
  def __ne__(self, other):
10340 
    return not (self == other)
10341 
 
10342 
class deleteItemFromCart_result:
10343 
  """
10344 
  Attributes:
10345 
   - scx
10346 
  """
10347 
 
10348 
  thrift_spec = (
10349 
    None, # 0
10350 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10351 
  )
10352 
 
10353 
  def __init__(self, scx=None,):
10354 
    self.scx = scx
10355 
 
10356 
  def read(self, iprot):
10357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10359 
      return
10360 
    iprot.readStructBegin()
10361 
    while True:
10362 
      (fname, ftype, fid) = iprot.readFieldBegin()
10363 
      if ftype == TType.STOP:
10364 
        break
10365 
      if fid == 1:
10366 
        if ftype == TType.STRUCT:
10367 
          self.scx = ShoppingCartException()
10368 
          self.scx.read(iprot)
10369 
        else:
10370 
          iprot.skip(ftype)
10371 
      else:
10372 
        iprot.skip(ftype)
10373 
      iprot.readFieldEnd()
10374 
    iprot.readStructEnd()
10375 
 
10376 
  def write(self, oprot):
10377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10379 
      return
10380 
    oprot.writeStructBegin('deleteItemFromCart_result')
10381 
    if self.scx != None:
10382 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10383 
      self.scx.write(oprot)
10384 
      oprot.writeFieldEnd()
10385 
    oprot.writeFieldStop()
10386 
    oprot.writeStructEnd()
10387 
 
10388 
  def __repr__(self):
10389 
    L = ['%s=%r' % (key, value)
10390 
      for key, value in self.__dict__.iteritems()]
10391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10392 
 
10393 
  def __eq__(self, other):
10394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10395 
 
10396 
  def __ne__(self, other):
10397 
    return not (self == other)
10398 
 
10399 
class changeQuantity_args:
10400 
  """
10401 
  Attributes:
10402 
   - cartId
10403 
   - itemId
10404 
   - quantity
10405 
  """
10406 
 
10407 
  thrift_spec = (
10408 
    None, # 0
10409 
    (1, TType.I64, 'cartId', None, None, ), # 1
10410 
    (2, TType.I64, 'itemId', None, None, ), # 2
10411 
    (3, TType.I64, 'quantity', None, None, ), # 3
10412 
  )
10413 
 
10414 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10415 
    self.cartId = cartId
10416 
    self.itemId = itemId
10417 
    self.quantity = quantity
10418 
 
10419 
  def read(self, iprot):
10420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10422 
      return
10423 
    iprot.readStructBegin()
10424 
    while True:
10425 
      (fname, ftype, fid) = iprot.readFieldBegin()
10426 
      if ftype == TType.STOP:
10427 
        break
10428 
      if fid == 1:
10429 
        if ftype == TType.I64:
10430 
          self.cartId = iprot.readI64();
10431 
        else:
10432 
          iprot.skip(ftype)
10433 
      elif fid == 2:
10434 
        if ftype == TType.I64:
10435 
          self.itemId = iprot.readI64();
10436 
        else:
10437 
          iprot.skip(ftype)
10438 
      elif fid == 3:
10439 
        if ftype == TType.I64:
10440 
          self.quantity = iprot.readI64();
10441 
        else:
10442 
          iprot.skip(ftype)
10443 
      else:
10444 
        iprot.skip(ftype)
10445 
      iprot.readFieldEnd()
10446 
    iprot.readStructEnd()
10447 
 
10448 
  def write(self, oprot):
10449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10451 
      return
10452 
    oprot.writeStructBegin('changeQuantity_args')
10453 
    if self.cartId != None:
10454 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10455 
      oprot.writeI64(self.cartId)
10456 
      oprot.writeFieldEnd()
10457 
    if self.itemId != None:
10458 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10459 
      oprot.writeI64(self.itemId)
10460 
      oprot.writeFieldEnd()
10461 
    if self.quantity != None:
10462 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10463 
      oprot.writeI64(self.quantity)
10464 
      oprot.writeFieldEnd()
10465 
    oprot.writeFieldStop()
10466 
    oprot.writeStructEnd()
10467 
 
10468 
  def __repr__(self):
10469 
    L = ['%s=%r' % (key, value)
10470 
      for key, value in self.__dict__.iteritems()]
10471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10472 
 
10473 
  def __eq__(self, other):
10474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10475 
 
10476 
  def __ne__(self, other):
10477 
    return not (self == other)
10478 
 
10479 
class changeQuantity_result:
10480 
  """
10481 
  Attributes:
10482 
   - scx
10483 
  """
10484 
 
10485 
  thrift_spec = (
10486 
    None, # 0
10487 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10488 
  )
10489 
 
10490 
  def __init__(self, scx=None,):
10491 
    self.scx = scx
10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 1:
10503 
        if ftype == TType.STRUCT:
10504 
          self.scx = ShoppingCartException()
10505 
          self.scx.read(iprot)
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      else:
10509 
        iprot.skip(ftype)
10510 
      iprot.readFieldEnd()
10511 
    iprot.readStructEnd()
10512 
 
10513 
  def write(self, oprot):
10514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10516 
      return
10517 
    oprot.writeStructBegin('changeQuantity_result')
10518 
    if self.scx != None:
10519 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10520 
      self.scx.write(oprot)
10521 
      oprot.writeFieldEnd()
10522 
    oprot.writeFieldStop()
10523 
    oprot.writeStructEnd()
10524 
 
10525 
  def __repr__(self):
10526 
    L = ['%s=%r' % (key, value)
10527 
      for key, value in self.__dict__.iteritems()]
10528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10529 
 
10530 
  def __eq__(self, other):
10531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10532 
 
10533 
  def __ne__(self, other):
10534 
    return not (self == other)
10535 
 
10536 
class changeItemStatus_args:
10537 
  """
10538 
  Attributes:
10539 
   - cartId
10540 
   - itemId
10541 
   - status
10542 
  """
10543 
 
10544 
  thrift_spec = (
10545 
    None, # 0
10546 
    (1, TType.I64, 'cartId', None, None, ), # 1
10547 
    (2, TType.I64, 'itemId', None, None, ), # 2
10548 
    (3, TType.I32, 'status', None, None, ), # 3
10549 
  )
10550 
 
10551 
  def __init__(self, cartId=None, itemId=None, status=None,):
10552 
    self.cartId = cartId
10553 
    self.itemId = itemId
10554 
    self.status = status
10555 
 
10556 
  def read(self, iprot):
10557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10559 
      return
10560 
    iprot.readStructBegin()
10561 
    while True:
10562 
      (fname, ftype, fid) = iprot.readFieldBegin()
10563 
      if ftype == TType.STOP:
10564 
        break
10565 
      if fid == 1:
10566 
        if ftype == TType.I64:
10567 
          self.cartId = iprot.readI64();
10568 
        else:
10569 
          iprot.skip(ftype)
10570 
      elif fid == 2:
10571 
        if ftype == TType.I64:
10572 
          self.itemId = iprot.readI64();
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      elif fid == 3:
10576 
        if ftype == TType.I32:
10577 
          self.status = iprot.readI32();
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('changeItemStatus_args')
10590 
    if self.cartId != None:
10591 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10592 
      oprot.writeI64(self.cartId)
10593 
      oprot.writeFieldEnd()
10594 
    if self.itemId != None:
10595 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10596 
      oprot.writeI64(self.itemId)
10597 
      oprot.writeFieldEnd()
10598 
    if self.status != None:
10599 
      oprot.writeFieldBegin('status', TType.I32, 3)
10600 
      oprot.writeI32(self.status)
10601 
      oprot.writeFieldEnd()
10602 
    oprot.writeFieldStop()
10603 
    oprot.writeStructEnd()
10604 
 
10605 
  def __repr__(self):
10606 
    L = ['%s=%r' % (key, value)
10607 
      for key, value in self.__dict__.iteritems()]
10608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10609 
 
10610 
  def __eq__(self, other):
10611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10612 
 
10613 
  def __ne__(self, other):
10614 
    return not (self == other)
10615 
 
10616 
class changeItemStatus_result:
10617 
  """
10618 
  Attributes:
10619 
   - scx
10620 
  """
10621 
 
10622 
  thrift_spec = (
10623 
    None, # 0
10624 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10625 
  )
10626 
 
10627 
  def __init__(self, scx=None,):
10628 
    self.scx = scx
10629 
 
10630 
  def read(self, iprot):
10631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10633 
      return
10634 
    iprot.readStructBegin()
10635 
    while True:
10636 
      (fname, ftype, fid) = iprot.readFieldBegin()
10637 
      if ftype == TType.STOP:
10638 
        break
10639 
      if fid == 1:
10640 
        if ftype == TType.STRUCT:
10641 
          self.scx = ShoppingCartException()
10642 
          self.scx.read(iprot)
10643 
        else:
10644 
          iprot.skip(ftype)
10645 
      else:
10646 
        iprot.skip(ftype)
10647 
      iprot.readFieldEnd()
10648 
    iprot.readStructEnd()
10649 
 
10650 
  def write(self, oprot):
10651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10653 
      return
10654 
    oprot.writeStructBegin('changeItemStatus_result')
10655 
    if self.scx != None:
10656 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10657 
      self.scx.write(oprot)
10658 
      oprot.writeFieldEnd()
10659 
    oprot.writeFieldStop()
10660 
    oprot.writeStructEnd()
10661 
 
10662 
  def __repr__(self):
10663 
    L = ['%s=%r' % (key, value)
10664 
      for key, value in self.__dict__.iteritems()]
10665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10666 
 
10667 
  def __eq__(self, other):
10668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10669 
 
10670 
  def __ne__(self, other):
10671 
    return not (self == other)
10672 
 
10673 
class addAddressToCart_args:
10674 
  """
10675 
  Attributes:
10676 
   - cartId
10677 
   - addressId
10678 
  """
10679 
 
10680 
  thrift_spec = (
10681 
    None, # 0
10682 
    (1, TType.I64, 'cartId', None, None, ), # 1
10683 
    (2, TType.I64, 'addressId', None, None, ), # 2
10684 
  )
10685 
 
10686 
  def __init__(self, cartId=None, addressId=None,):
10687 
    self.cartId = cartId
10688 
    self.addressId = addressId
10689 
 
10690 
  def read(self, iprot):
10691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10693 
      return
10694 
    iprot.readStructBegin()
10695 
    while True:
10696 
      (fname, ftype, fid) = iprot.readFieldBegin()
10697 
      if ftype == TType.STOP:
10698 
        break
10699 
      if fid == 1:
10700 
        if ftype == TType.I64:
10701 
          self.cartId = iprot.readI64();
10702 
        else:
10703 
          iprot.skip(ftype)
10704 
      elif fid == 2:
10705 
        if ftype == TType.I64:
10706 
          self.addressId = iprot.readI64();
10707 
        else:
10708 
          iprot.skip(ftype)
10709 
      else:
10710 
        iprot.skip(ftype)
10711 
      iprot.readFieldEnd()
10712 
    iprot.readStructEnd()
10713 
 
10714 
  def write(self, oprot):
10715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10717 
      return
10718 
    oprot.writeStructBegin('addAddressToCart_args')
10719 
    if self.cartId != None:
10720 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10721 
      oprot.writeI64(self.cartId)
10722 
      oprot.writeFieldEnd()
10723 
    if self.addressId != None:
10724 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10725 
      oprot.writeI64(self.addressId)
10726 
      oprot.writeFieldEnd()
10727 
    oprot.writeFieldStop()
10728 
    oprot.writeStructEnd()
10729 
 
10730 
  def __repr__(self):
10731 
    L = ['%s=%r' % (key, value)
10732 
      for key, value in self.__dict__.iteritems()]
10733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10734 
 
10735 
  def __eq__(self, other):
10736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10737 
 
10738 
  def __ne__(self, other):
10739 
    return not (self == other)
10740 
 
10741 
class addAddressToCart_result:
575 chandransh 10742 
  """
10743 
  Attributes:
10744 
   - scx
10745 
  """
559 chandransh 10746 
 
10747 
  thrift_spec = (
575 chandransh 10748 
    None, # 0
10749 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10750 
  )
10751 
 
575 chandransh 10752 
  def __init__(self, scx=None,):
10753 
    self.scx = scx
10754 
 
559 chandransh 10755 
  def read(self, iprot):
10756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10758 
      return
10759 
    iprot.readStructBegin()
10760 
    while True:
10761 
      (fname, ftype, fid) = iprot.readFieldBegin()
10762 
      if ftype == TType.STOP:
10763 
        break
575 chandransh 10764 
      if fid == 1:
10765 
        if ftype == TType.STRUCT:
10766 
          self.scx = ShoppingCartException()
10767 
          self.scx.read(iprot)
10768 
        else:
10769 
          iprot.skip(ftype)
559 chandransh 10770 
      else:
10771 
        iprot.skip(ftype)
10772 
      iprot.readFieldEnd()
10773 
    iprot.readStructEnd()
10774 
 
10775 
  def write(self, oprot):
10776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10778 
      return
10779 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10780 
    if self.scx != None:
10781 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10782 
      self.scx.write(oprot)
10783 
      oprot.writeFieldEnd()
559 chandransh 10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
10787 
  def __repr__(self):
10788 
    L = ['%s=%r' % (key, value)
10789 
      for key, value in self.__dict__.iteritems()]
10790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10791 
 
10792 
  def __eq__(self, other):
10793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10794 
 
10795 
  def __ne__(self, other):
10796 
    return not (self == other)
10797 
 
1976 varun.gupt 10798 
class applyCouponToCart_args:
10799 
  """
10800 
  Attributes:
10801 
   - cartId
10802 
   - couponCode
10803 
   - totalPrice
10804 
   - discountedPrice
10805 
  """
10806 
 
10807 
  thrift_spec = (
10808 
    None, # 0
10809 
    (1, TType.I64, 'cartId', None, None, ), # 1
10810 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10811 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10812 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10813 
  )
10814 
 
10815 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10816 
    self.cartId = cartId
10817 
    self.couponCode = couponCode
10818 
    self.totalPrice = totalPrice
10819 
    self.discountedPrice = discountedPrice
10820 
 
10821 
  def read(self, iprot):
10822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10824 
      return
10825 
    iprot.readStructBegin()
10826 
    while True:
10827 
      (fname, ftype, fid) = iprot.readFieldBegin()
10828 
      if ftype == TType.STOP:
10829 
        break
10830 
      if fid == 1:
10831 
        if ftype == TType.I64:
10832 
          self.cartId = iprot.readI64();
10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      elif fid == 2:
10836 
        if ftype == TType.STRING:
10837 
          self.couponCode = iprot.readString();
10838 
        else:
10839 
          iprot.skip(ftype)
10840 
      elif fid == 3:
10841 
        if ftype == TType.DOUBLE:
10842 
          self.totalPrice = iprot.readDouble();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 4:
10846 
        if ftype == TType.DOUBLE:
10847 
          self.discountedPrice = iprot.readDouble();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
10859 
    oprot.writeStructBegin('applyCouponToCart_args')
10860 
    if self.cartId != None:
10861 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10862 
      oprot.writeI64(self.cartId)
10863 
      oprot.writeFieldEnd()
10864 
    if self.couponCode != None:
10865 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10866 
      oprot.writeString(self.couponCode)
10867 
      oprot.writeFieldEnd()
10868 
    if self.totalPrice != None:
10869 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10870 
      oprot.writeDouble(self.totalPrice)
10871 
      oprot.writeFieldEnd()
10872 
    if self.discountedPrice != None:
10873 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10874 
      oprot.writeDouble(self.discountedPrice)
10875 
      oprot.writeFieldEnd()
10876 
    oprot.writeFieldStop()
10877 
    oprot.writeStructEnd()
10878 
 
10879 
  def __repr__(self):
10880 
    L = ['%s=%r' % (key, value)
10881 
      for key, value in self.__dict__.iteritems()]
10882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10883 
 
10884 
  def __eq__(self, other):
10885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10886 
 
10887 
  def __ne__(self, other):
10888 
    return not (self == other)
10889 
 
10890 
class applyCouponToCart_result:
10891 
  """
10892 
  Attributes:
10893 
   - scx
10894 
  """
10895 
 
10896 
  thrift_spec = (
10897 
    None, # 0
10898 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10899 
  )
10900 
 
10901 
  def __init__(self, scx=None,):
10902 
    self.scx = scx
10903 
 
10904 
  def read(self, iprot):
10905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10907 
      return
10908 
    iprot.readStructBegin()
10909 
    while True:
10910 
      (fname, ftype, fid) = iprot.readFieldBegin()
10911 
      if ftype == TType.STOP:
10912 
        break
10913 
      if fid == 1:
10914 
        if ftype == TType.STRUCT:
10915 
          self.scx = ShoppingCartException()
10916 
          self.scx.read(iprot)
10917 
        else:
10918 
          iprot.skip(ftype)
10919 
      else:
10920 
        iprot.skip(ftype)
10921 
      iprot.readFieldEnd()
10922 
    iprot.readStructEnd()
10923 
 
10924 
  def write(self, oprot):
10925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10927 
      return
10928 
    oprot.writeStructBegin('applyCouponToCart_result')
10929 
    if self.scx != None:
10930 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10931 
      self.scx.write(oprot)
10932 
      oprot.writeFieldEnd()
10933 
    oprot.writeFieldStop()
10934 
    oprot.writeStructEnd()
10935 
 
10936 
  def __repr__(self):
10937 
    L = ['%s=%r' % (key, value)
10938 
      for key, value in self.__dict__.iteritems()]
10939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10940 
 
10941 
  def __eq__(self, other):
10942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10943 
 
10944 
  def __ne__(self, other):
10945 
    return not (self == other)
10946 
 
10947 
class removeCoupon_args:
10948 
  """
10949 
  Attributes:
10950 
   - cartId
10951 
  """
10952 
 
10953 
  thrift_spec = (
10954 
    None, # 0
10955 
    (1, TType.I64, 'cartId', None, None, ), # 1
10956 
  )
10957 
 
10958 
  def __init__(self, cartId=None,):
10959 
    self.cartId = cartId
10960 
 
10961 
  def read(self, iprot):
10962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10964 
      return
10965 
    iprot.readStructBegin()
10966 
    while True:
10967 
      (fname, ftype, fid) = iprot.readFieldBegin()
10968 
      if ftype == TType.STOP:
10969 
        break
10970 
      if fid == 1:
10971 
        if ftype == TType.I64:
10972 
          self.cartId = iprot.readI64();
10973 
        else:
10974 
          iprot.skip(ftype)
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
10984 
    oprot.writeStructBegin('removeCoupon_args')
10985 
    if self.cartId != None:
10986 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10987 
      oprot.writeI64(self.cartId)
10988 
      oprot.writeFieldEnd()
10989 
    oprot.writeFieldStop()
10990 
    oprot.writeStructEnd()
10991 
 
10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
11003 
class removeCoupon_result:
11004 
  """
11005 
  Attributes:
11006 
   - scx
11007 
  """
11008 
 
11009 
  thrift_spec = (
11010 
    None, # 0
11011 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11012 
  )
11013 
 
11014 
  def __init__(self, scx=None,):
11015 
    self.scx = scx
11016 
 
11017 
  def read(self, iprot):
11018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11020 
      return
11021 
    iprot.readStructBegin()
11022 
    while True:
11023 
      (fname, ftype, fid) = iprot.readFieldBegin()
11024 
      if ftype == TType.STOP:
11025 
        break
11026 
      if fid == 1:
11027 
        if ftype == TType.STRUCT:
11028 
          self.scx = ShoppingCartException()
11029 
          self.scx.read(iprot)
11030 
        else:
11031 
          iprot.skip(ftype)
11032 
      else:
11033 
        iprot.skip(ftype)
11034 
      iprot.readFieldEnd()
11035 
    iprot.readStructEnd()
11036 
 
11037 
  def write(self, oprot):
11038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11040 
      return
11041 
    oprot.writeStructBegin('removeCoupon_result')
11042 
    if self.scx != None:
11043 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11044 
      self.scx.write(oprot)
11045 
      oprot.writeFieldEnd()
11046 
    oprot.writeFieldStop()
11047 
    oprot.writeStructEnd()
11048 
 
11049 
  def __repr__(self):
11050 
    L = ['%s=%r' % (key, value)
11051 
      for key, value in self.__dict__.iteritems()]
11052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11053 
 
11054 
  def __eq__(self, other):
11055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11056 
 
11057 
  def __ne__(self, other):
11058 
    return not (self == other)
11059 
 
690 chandransh 11060 
class createOrders_args:
559 chandransh 11061 
  """
11062 
  Attributes:
11063 
   - cartId
2815 vikas 11064 
   - sessionSource
11065 
   - sessionStartTime
559 chandransh 11066 
  """
11067 
 
11068 
  thrift_spec = (
11069 
    None, # 0
11070 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11071 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11072 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 11073 
  )
11074 
 
2815 vikas 11075 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 11076 
    self.cartId = cartId
2815 vikas 11077 
    self.sessionSource = sessionSource
11078 
    self.sessionStartTime = sessionStartTime
559 chandransh 11079 
 
11080 
  def read(self, iprot):
11081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11083 
      return
11084 
    iprot.readStructBegin()
11085 
    while True:
11086 
      (fname, ftype, fid) = iprot.readFieldBegin()
11087 
      if ftype == TType.STOP:
11088 
        break
11089 
      if fid == 1:
11090 
        if ftype == TType.I64:
11091 
          self.cartId = iprot.readI64();
11092 
        else:
11093 
          iprot.skip(ftype)
2815 vikas 11094 
      elif fid == 2:
11095 
        if ftype == TType.STRING:
11096 
          self.sessionSource = iprot.readString();
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      elif fid == 3:
11100 
        if ftype == TType.I64:
11101 
          self.sessionStartTime = iprot.readI64();
11102 
        else:
11103 
          iprot.skip(ftype)
559 chandransh 11104 
      else:
11105 
        iprot.skip(ftype)
11106 
      iprot.readFieldEnd()
11107 
    iprot.readStructEnd()
11108 
 
11109 
  def write(self, oprot):
11110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11112 
      return
690 chandransh 11113 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 11114 
    if self.cartId != None:
11115 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11116 
      oprot.writeI64(self.cartId)
11117 
      oprot.writeFieldEnd()
2815 vikas 11118 
    if self.sessionSource != None:
11119 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11120 
      oprot.writeString(self.sessionSource)
11121 
      oprot.writeFieldEnd()
11122 
    if self.sessionStartTime != None:
11123 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11124 
      oprot.writeI64(self.sessionStartTime)
11125 
      oprot.writeFieldEnd()
559 chandransh 11126 
    oprot.writeFieldStop()
11127 
    oprot.writeStructEnd()
11128 
 
11129 
  def __repr__(self):
11130 
    L = ['%s=%r' % (key, value)
11131 
      for key, value in self.__dict__.iteritems()]
11132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11133 
 
11134 
  def __eq__(self, other):
11135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11136 
 
11137 
  def __ne__(self, other):
11138 
    return not (self == other)
11139 
 
690 chandransh 11140 
class createOrders_result:
559 chandransh 11141 
  """
11142 
  Attributes:
94 ashish 11143 
   - success
559 chandransh 11144 
   - scx
94 ashish 11145 
  """
11146 
 
11147 
  thrift_spec = (
575 chandransh 11148 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11149 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11150 
  )
11151 
 
559 chandransh 11152 
  def __init__(self, success=None, scx=None,):
94 ashish 11153 
    self.success = success
559 chandransh 11154 
    self.scx = scx
94 ashish 11155 
 
11156 
  def read(self, iprot):
11157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11159 
      return
11160 
    iprot.readStructBegin()
11161 
    while True:
11162 
      (fname, ftype, fid) = iprot.readFieldBegin()
11163 
      if ftype == TType.STOP:
11164 
        break
11165 
      if fid == 0:
575 chandransh 11166 
        if ftype == TType.I64:
11167 
          self.success = iprot.readI64();
94 ashish 11168 
        else:
11169 
          iprot.skip(ftype)
11170 
      elif fid == 1:
11171 
        if ftype == TType.STRUCT:
559 chandransh 11172 
          self.scx = ShoppingCartException()
11173 
          self.scx.read(iprot)
94 ashish 11174 
        else:
11175 
          iprot.skip(ftype)
11176 
      else:
11177 
        iprot.skip(ftype)
11178 
      iprot.readFieldEnd()
11179 
    iprot.readStructEnd()
11180 
 
11181 
  def write(self, oprot):
11182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11184 
      return
690 chandransh 11185 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11186 
    if self.success != None:
575 chandransh 11187 
      oprot.writeFieldBegin('success', TType.I64, 0)
11188 
      oprot.writeI64(self.success)
94 ashish 11189 
      oprot.writeFieldEnd()
559 chandransh 11190 
    if self.scx != None:
11191 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11192 
      self.scx.write(oprot)
94 ashish 11193 
      oprot.writeFieldEnd()
11194 
    oprot.writeFieldStop()
11195 
    oprot.writeStructEnd()
11196 
 
11197 
  def __repr__(self):
11198 
    L = ['%s=%r' % (key, value)
11199 
      for key, value in self.__dict__.iteritems()]
11200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11201 
 
11202 
  def __eq__(self, other):
11203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11204 
 
11205 
  def __ne__(self, other):
11206 
    return not (self == other)
11207 
 
559 chandransh 11208 
class validateCart_args:
94 ashish 11209 
  """
11210 
  Attributes:
559 chandransh 11211 
   - cartId
94 ashish 11212 
  """
11213 
 
11214 
  thrift_spec = (
11215 
    None, # 0
559 chandransh 11216 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11217 
  )
11218 
 
559 chandransh 11219 
  def __init__(self, cartId=None,):
11220 
    self.cartId = cartId
94 ashish 11221 
 
11222 
  def read(self, iprot):
11223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11225 
      return
11226 
    iprot.readStructBegin()
11227 
    while True:
11228 
      (fname, ftype, fid) = iprot.readFieldBegin()
11229 
      if ftype == TType.STOP:
11230 
        break
11231 
      if fid == 1:
11232 
        if ftype == TType.I64:
559 chandransh 11233 
          self.cartId = iprot.readI64();
94 ashish 11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      else:
11237 
        iprot.skip(ftype)
11238 
      iprot.readFieldEnd()
11239 
    iprot.readStructEnd()
11240 
 
11241 
  def write(self, oprot):
11242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11244 
      return
559 chandransh 11245 
    oprot.writeStructBegin('validateCart_args')
11246 
    if self.cartId != None:
11247 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11248 
      oprot.writeI64(self.cartId)
94 ashish 11249 
      oprot.writeFieldEnd()
11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
11253 
  def __repr__(self):
11254 
    L = ['%s=%r' % (key, value)
11255 
      for key, value in self.__dict__.iteritems()]
11256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11257 
 
11258 
  def __eq__(self, other):
11259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11260 
 
11261 
  def __ne__(self, other):
11262 
    return not (self == other)
11263 
 
559 chandransh 11264 
class validateCart_result:
94 ashish 11265 
  """
11266 
  Attributes:
11267 
   - success
575 chandransh 11268 
   - scex
94 ashish 11269 
  """
11270 
 
11271 
  thrift_spec = (
1466 ankur.sing 11272 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11273 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11274 
  )
11275 
 
575 chandransh 11276 
  def __init__(self, success=None, scex=None,):
94 ashish 11277 
    self.success = success
575 chandransh 11278 
    self.scex = scex
94 ashish 11279 
 
11280 
  def read(self, iprot):
11281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11283 
      return
11284 
    iprot.readStructBegin()
11285 
    while True:
11286 
      (fname, ftype, fid) = iprot.readFieldBegin()
11287 
      if ftype == TType.STOP:
11288 
        break
11289 
      if fid == 0:
1466 ankur.sing 11290 
        if ftype == TType.STRING:
11291 
          self.success = iprot.readString();
94 ashish 11292 
        else:
11293 
          iprot.skip(ftype)
575 chandransh 11294 
      elif fid == 1:
11295 
        if ftype == TType.STRUCT:
11296 
          self.scex = ShoppingCartException()
11297 
          self.scex.read(iprot)
11298 
        else:
11299 
          iprot.skip(ftype)
94 ashish 11300 
      else:
11301 
        iprot.skip(ftype)
11302 
      iprot.readFieldEnd()
11303 
    iprot.readStructEnd()
11304 
 
11305 
  def write(self, oprot):
11306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11308 
      return
559 chandransh 11309 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11310 
    if self.success != None:
1466 ankur.sing 11311 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11312 
      oprot.writeString(self.success)
94 ashish 11313 
      oprot.writeFieldEnd()
575 chandransh 11314 
    if self.scex != None:
11315 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11316 
      self.scex.write(oprot)
11317 
      oprot.writeFieldEnd()
559 chandransh 11318 
    oprot.writeFieldStop()
11319 
    oprot.writeStructEnd()
11320 
 
11321 
  def __repr__(self):
11322 
    L = ['%s=%r' % (key, value)
11323 
      for key, value in self.__dict__.iteritems()]
11324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11325 
 
11326 
  def __eq__(self, other):
11327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11328 
 
11329 
  def __ne__(self, other):
11330 
    return not (self == other)
11331 
 
690 chandransh 11332 
class mergeCart_args:
575 chandransh 11333 
  """
11334 
  Attributes:
690 chandransh 11335 
   - fromCartId
11336 
   - toCartId
11337 
  """
11338 
 
11339 
  thrift_spec = (
11340 
    None, # 0
11341 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11342 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11343 
  )
11344 
 
11345 
  def __init__(self, fromCartId=None, toCartId=None,):
11346 
    self.fromCartId = fromCartId
11347 
    self.toCartId = toCartId
11348 
 
11349 
  def read(self, iprot):
11350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11352 
      return
11353 
    iprot.readStructBegin()
11354 
    while True:
11355 
      (fname, ftype, fid) = iprot.readFieldBegin()
11356 
      if ftype == TType.STOP:
11357 
        break
11358 
      if fid == 1:
11359 
        if ftype == TType.I64:
11360 
          self.fromCartId = iprot.readI64();
11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      elif fid == 2:
11364 
        if ftype == TType.I64:
11365 
          self.toCartId = iprot.readI64();
11366 
        else:
11367 
          iprot.skip(ftype)
11368 
      else:
11369 
        iprot.skip(ftype)
11370 
      iprot.readFieldEnd()
11371 
    iprot.readStructEnd()
11372 
 
11373 
  def write(self, oprot):
11374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11376 
      return
11377 
    oprot.writeStructBegin('mergeCart_args')
11378 
    if self.fromCartId != None:
11379 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11380 
      oprot.writeI64(self.fromCartId)
11381 
      oprot.writeFieldEnd()
11382 
    if self.toCartId != None:
11383 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11384 
      oprot.writeI64(self.toCartId)
11385 
      oprot.writeFieldEnd()
11386 
    oprot.writeFieldStop()
11387 
    oprot.writeStructEnd()
11388 
 
11389 
  def __repr__(self):
11390 
    L = ['%s=%r' % (key, value)
11391 
      for key, value in self.__dict__.iteritems()]
11392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11393 
 
11394 
  def __eq__(self, other):
11395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11396 
 
11397 
  def __ne__(self, other):
11398 
    return not (self == other)
11399 
 
11400 
class mergeCart_result:
11401 
 
11402 
  thrift_spec = (
11403 
  )
11404 
 
11405 
  def read(self, iprot):
11406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11408 
      return
11409 
    iprot.readStructBegin()
11410 
    while True:
11411 
      (fname, ftype, fid) = iprot.readFieldBegin()
11412 
      if ftype == TType.STOP:
11413 
        break
11414 
      else:
11415 
        iprot.skip(ftype)
11416 
      iprot.readFieldEnd()
11417 
    iprot.readStructEnd()
11418 
 
11419 
  def write(self, oprot):
11420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11422 
      return
11423 
    oprot.writeStructBegin('mergeCart_result')
11424 
    oprot.writeFieldStop()
11425 
    oprot.writeStructEnd()
11426 
 
11427 
  def __repr__(self):
11428 
    L = ['%s=%r' % (key, value)
11429 
      for key, value in self.__dict__.iteritems()]
11430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11431 
 
11432 
  def __eq__(self, other):
11433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11434 
 
11435 
  def __ne__(self, other):
11436 
    return not (self == other)
11437 
 
11438 
class checkOut_args:
11439 
  """
11440 
  Attributes:
575 chandransh 11441 
   - cartId
11442 
  """
11443 
 
11444 
  thrift_spec = (
11445 
    None, # 0
11446 
    (1, TType.I64, 'cartId', None, None, ), # 1
11447 
  )
11448 
 
11449 
  def __init__(self, cartId=None,):
11450 
    self.cartId = cartId
11451 
 
11452 
  def read(self, iprot):
11453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11455 
      return
11456 
    iprot.readStructBegin()
11457 
    while True:
11458 
      (fname, ftype, fid) = iprot.readFieldBegin()
11459 
      if ftype == TType.STOP:
11460 
        break
11461 
      if fid == 1:
11462 
        if ftype == TType.I64:
11463 
          self.cartId = iprot.readI64();
11464 
        else:
11465 
          iprot.skip(ftype)
11466 
      else:
11467 
        iprot.skip(ftype)
11468 
      iprot.readFieldEnd()
11469 
    iprot.readStructEnd()
11470 
 
11471 
  def write(self, oprot):
11472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11474 
      return
690 chandransh 11475 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11476 
    if self.cartId != None:
11477 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11478 
      oprot.writeI64(self.cartId)
11479 
      oprot.writeFieldEnd()
11480 
    oprot.writeFieldStop()
11481 
    oprot.writeStructEnd()
11482 
 
11483 
  def __repr__(self):
11484 
    L = ['%s=%r' % (key, value)
11485 
      for key, value in self.__dict__.iteritems()]
11486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11487 
 
11488 
  def __eq__(self, other):
11489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11490 
 
11491 
  def __ne__(self, other):
11492 
    return not (self == other)
11493 
 
690 chandransh 11494 
class checkOut_result:
575 chandransh 11495 
  """
11496 
  Attributes:
11497 
   - success
11498 
   - scex
11499 
  """
11500 
 
11501 
  thrift_spec = (
11502 
    (0, TType.BOOL, 'success', None, None, ), # 0
11503 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11504 
  )
11505 
 
11506 
  def __init__(self, success=None, scex=None,):
11507 
    self.success = success
11508 
    self.scex = scex
11509 
 
11510 
  def read(self, iprot):
11511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11513 
      return
11514 
    iprot.readStructBegin()
11515 
    while True:
11516 
      (fname, ftype, fid) = iprot.readFieldBegin()
11517 
      if ftype == TType.STOP:
11518 
        break
11519 
      if fid == 0:
11520 
        if ftype == TType.BOOL:
11521 
          self.success = iprot.readBool();
11522 
        else:
11523 
          iprot.skip(ftype)
11524 
      elif fid == 1:
11525 
        if ftype == TType.STRUCT:
11526 
          self.scex = ShoppingCartException()
11527 
          self.scex.read(iprot)
11528 
        else:
11529 
          iprot.skip(ftype)
11530 
      else:
11531 
        iprot.skip(ftype)
11532 
      iprot.readFieldEnd()
11533 
    iprot.readStructEnd()
11534 
 
11535 
  def write(self, oprot):
11536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11538 
      return
690 chandransh 11539 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11540 
    if self.success != None:
11541 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11542 
      oprot.writeBool(self.success)
11543 
      oprot.writeFieldEnd()
11544 
    if self.scex != None:
11545 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11546 
      self.scex.write(oprot)
11547 
      oprot.writeFieldEnd()
11548 
    oprot.writeFieldStop()
11549 
    oprot.writeStructEnd()
11550 
 
11551 
  def __repr__(self):
11552 
    L = ['%s=%r' % (key, value)
11553 
      for key, value in self.__dict__.iteritems()]
11554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11555 
 
11556 
  def __eq__(self, other):
11557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11558 
 
11559 
  def __ne__(self, other):
11560 
    return not (self == other)
11561 
 
690 chandransh 11562 
class resetCart_args:
559 chandransh 11563 
  """
11564 
  Attributes:
690 chandransh 11565 
   - cartId
11566 
   - items
559 chandransh 11567 
  """
11568 
 
11569 
  thrift_spec = (
11570 
    None, # 0
690 chandransh 11571 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11572 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11573 
  )
11574 
 
690 chandransh 11575 
  def __init__(self, cartId=None, items=None,):
11576 
    self.cartId = cartId
11577 
    self.items = items
559 chandransh 11578 
 
11579 
  def read(self, iprot):
11580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11582 
      return
11583 
    iprot.readStructBegin()
11584 
    while True:
11585 
      (fname, ftype, fid) = iprot.readFieldBegin()
11586 
      if ftype == TType.STOP:
11587 
        break
11588 
      if fid == 1:
11589 
        if ftype == TType.I64:
690 chandransh 11590 
          self.cartId = iprot.readI64();
559 chandransh 11591 
        else:
11592 
          iprot.skip(ftype)
11593 
      elif fid == 2:
690 chandransh 11594 
        if ftype == TType.MAP:
11595 
          self.items = {}
2981 rajveer 11596 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
11597 
          for _i109 in xrange(_size105):
11598 
            _key110 = iprot.readI64();
11599 
            _val111 = iprot.readDouble();
11600 
            self.items[_key110] = _val111
690 chandransh 11601 
          iprot.readMapEnd()
559 chandransh 11602 
        else:
11603 
          iprot.skip(ftype)
11604 
      else:
11605 
        iprot.skip(ftype)
11606 
      iprot.readFieldEnd()
11607 
    iprot.readStructEnd()
11608 
 
11609 
  def write(self, oprot):
11610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11612 
      return
690 chandransh 11613 
    oprot.writeStructBegin('resetCart_args')
11614 
    if self.cartId != None:
11615 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11616 
      oprot.writeI64(self.cartId)
94 ashish 11617 
      oprot.writeFieldEnd()
690 chandransh 11618 
    if self.items != None:
11619 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11620 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
2981 rajveer 11621 
      for kiter112,viter113 in self.items.items():
11622 
        oprot.writeI64(kiter112)
11623 
        oprot.writeDouble(viter113)
690 chandransh 11624 
      oprot.writeMapEnd()
559 chandransh 11625 
      oprot.writeFieldEnd()
94 ashish 11626 
    oprot.writeFieldStop()
11627 
    oprot.writeStructEnd()
11628 
 
11629 
  def __repr__(self):
11630 
    L = ['%s=%r' % (key, value)
11631 
      for key, value in self.__dict__.iteritems()]
11632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11633 
 
11634 
  def __eq__(self, other):
11635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11636 
 
11637 
  def __ne__(self, other):
11638 
    return not (self == other)
11639 
 
690 chandransh 11640 
class resetCart_result:
11641 
  """
11642 
  Attributes:
11643 
   - success
11644 
   - scex
11645 
  """
559 chandransh 11646 
 
11647 
  thrift_spec = (
690 chandransh 11648 
    (0, TType.BOOL, 'success', None, None, ), # 0
11649 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11650 
  )
11651 
 
690 chandransh 11652 
  def __init__(self, success=None, scex=None,):
11653 
    self.success = success
11654 
    self.scex = scex
11655 
 
559 chandransh 11656 
  def read(self, iprot):
11657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11659 
      return
11660 
    iprot.readStructBegin()
11661 
    while True:
11662 
      (fname, ftype, fid) = iprot.readFieldBegin()
11663 
      if ftype == TType.STOP:
11664 
        break
690 chandransh 11665 
      if fid == 0:
11666 
        if ftype == TType.BOOL:
11667 
          self.success = iprot.readBool();
11668 
        else:
11669 
          iprot.skip(ftype)
11670 
      elif fid == 1:
11671 
        if ftype == TType.STRUCT:
11672 
          self.scex = ShoppingCartException()
11673 
          self.scex.read(iprot)
11674 
        else:
11675 
          iprot.skip(ftype)
559 chandransh 11676 
      else:
11677 
        iprot.skip(ftype)
11678 
      iprot.readFieldEnd()
11679 
    iprot.readStructEnd()
11680 
 
11681 
  def write(self, oprot):
11682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11684 
      return
690 chandransh 11685 
    oprot.writeStructBegin('resetCart_result')
11686 
    if self.success != None:
11687 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11688 
      oprot.writeBool(self.success)
11689 
      oprot.writeFieldEnd()
11690 
    if self.scex != None:
11691 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11692 
      self.scex.write(oprot)
11693 
      oprot.writeFieldEnd()
559 chandransh 11694 
    oprot.writeFieldStop()
11695 
    oprot.writeStructEnd()
11696 
 
11697 
  def __repr__(self):
11698 
    L = ['%s=%r' % (key, value)
11699 
      for key, value in self.__dict__.iteritems()]
11700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11701 
 
11702 
  def __eq__(self, other):
11703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11704 
 
11705 
  def __ne__(self, other):
11706 
    return not (self == other)
11707 
 
2981 rajveer 11708 
class getUserCount_args:
94 ashish 11709 
  """
11710 
  Attributes:
2981 rajveer 11711 
   - userType
559 chandransh 11712 
  """
11713 
 
11714 
  thrift_spec = (
11715 
    None, # 0
2981 rajveer 11716 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11717 
  )
11718 
 
2981 rajveer 11719 
  def __init__(self, userType=None,):
11720 
    self.userType = userType
559 chandransh 11721 
 
11722 
  def read(self, iprot):
11723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11725 
      return
11726 
    iprot.readStructBegin()
11727 
    while True:
11728 
      (fname, ftype, fid) = iprot.readFieldBegin()
11729 
      if ftype == TType.STOP:
11730 
        break
11731 
      if fid == 1:
2981 rajveer 11732 
        if ftype == TType.I32:
11733 
          self.userType = iprot.readI32();
559 chandransh 11734 
        else:
11735 
          iprot.skip(ftype)
11736 
      else:
11737 
        iprot.skip(ftype)
11738 
      iprot.readFieldEnd()
11739 
    iprot.readStructEnd()
11740 
 
11741 
  def write(self, oprot):
11742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11744 
      return
2981 rajveer 11745 
    oprot.writeStructBegin('getUserCount_args')
11746 
    if self.userType != None:
11747 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11748 
      oprot.writeI32(self.userType)
559 chandransh 11749 
      oprot.writeFieldEnd()
11750 
    oprot.writeFieldStop()
11751 
    oprot.writeStructEnd()
11752 
 
11753 
  def __repr__(self):
11754 
    L = ['%s=%r' % (key, value)
11755 
      for key, value in self.__dict__.iteritems()]
11756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11757 
 
11758 
  def __eq__(self, other):
11759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11760 
 
11761 
  def __ne__(self, other):
11762 
    return not (self == other)
11763 
 
2981 rajveer 11764 
class getUserCount_result:
94 ashish 11765 
  """
11766 
  Attributes:
11767 
   - success
11768 
  """
11769 
 
11770 
  thrift_spec = (
2981 rajveer 11771 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11772 
  )
11773 
 
2981 rajveer 11774 
  def __init__(self, success=None,):
94 ashish 11775 
    self.success = success
11776 
 
11777 
  def read(self, iprot):
11778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11780 
      return
11781 
    iprot.readStructBegin()
11782 
    while True:
11783 
      (fname, ftype, fid) = iprot.readFieldBegin()
11784 
      if ftype == TType.STOP:
11785 
        break
11786 
      if fid == 0:
2981 rajveer 11787 
        if ftype == TType.I64:
11788 
          self.success = iprot.readI64();
94 ashish 11789 
        else:
11790 
          iprot.skip(ftype)
11791 
      else:
11792 
        iprot.skip(ftype)
11793 
      iprot.readFieldEnd()
11794 
    iprot.readStructEnd()
11795 
 
11796 
  def write(self, oprot):
11797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11799 
      return
2981 rajveer 11800 
    oprot.writeStructBegin('getUserCount_result')
94 ashish 11801 
    if self.success != None:
2981 rajveer 11802 
      oprot.writeFieldBegin('success', TType.I64, 0)
11803 
      oprot.writeI64(self.success)
94 ashish 11804 
      oprot.writeFieldEnd()
11805 
    oprot.writeFieldStop()
11806 
    oprot.writeStructEnd()
11807 
 
11808 
  def __repr__(self):
11809 
    L = ['%s=%r' % (key, value)
11810 
      for key, value in self.__dict__.iteritems()]
11811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11812 
 
11813 
  def __eq__(self, other):
11814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11815 
 
11816 
  def __ne__(self, other):
11817 
    return not (self == other)
11818 
 
2981 rajveer 11819 
class getAllUsers_args:
94 ashish 11820 
  """
11821 
  Attributes:
2981 rajveer 11822 
   - userType
11823 
   - startDate
11824 
   - endDate
94 ashish 11825 
  """
11826 
 
11827 
  thrift_spec = (
11828 
    None, # 0
2981 rajveer 11829 
    (1, TType.I32, 'userType', None, None, ), # 1
11830 
    (2, TType.I64, 'startDate', None, None, ), # 2
11831 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 11832 
  )
11833 
 
2981 rajveer 11834 
  def __init__(self, userType=None, startDate=None, endDate=None,):
11835 
    self.userType = userType
11836 
    self.startDate = startDate
11837 
    self.endDate = endDate
94 ashish 11838 
 
11839 
  def read(self, iprot):
11840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11842 
      return
11843 
    iprot.readStructBegin()
11844 
    while True:
11845 
      (fname, ftype, fid) = iprot.readFieldBegin()
11846 
      if ftype == TType.STOP:
11847 
        break
11848 
      if fid == 1:
2981 rajveer 11849 
        if ftype == TType.I32:
11850 
          self.userType = iprot.readI32();
94 ashish 11851 
        else:
11852 
          iprot.skip(ftype)
11853 
      elif fid == 2:
559 chandransh 11854 
        if ftype == TType.I64:
2981 rajveer 11855 
          self.startDate = iprot.readI64();
94 ashish 11856 
        else:
11857 
          iprot.skip(ftype)
2981 rajveer 11858 
      elif fid == 3:
11859 
        if ftype == TType.I64:
11860 
          self.endDate = iprot.readI64();
11861 
        else:
11862 
          iprot.skip(ftype)
94 ashish 11863 
      else:
11864 
        iprot.skip(ftype)
11865 
      iprot.readFieldEnd()
11866 
    iprot.readStructEnd()
11867 
 
11868 
  def write(self, oprot):
11869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11871 
      return
2981 rajveer 11872 
    oprot.writeStructBegin('getAllUsers_args')
11873 
    if self.userType != None:
11874 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11875 
      oprot.writeI32(self.userType)
94 ashish 11876 
      oprot.writeFieldEnd()
2981 rajveer 11877 
    if self.startDate != None:
11878 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
11879 
      oprot.writeI64(self.startDate)
94 ashish 11880 
      oprot.writeFieldEnd()
2981 rajveer 11881 
    if self.endDate != None:
11882 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
11883 
      oprot.writeI64(self.endDate)
11884 
      oprot.writeFieldEnd()
94 ashish 11885 
    oprot.writeFieldStop()
11886 
    oprot.writeStructEnd()
11887 
 
11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
2981 rajveer 11899 
class getAllUsers_result:
94 ashish 11900 
  """
11901 
  Attributes:
11902 
   - success
11903 
  """
11904 
 
11905 
  thrift_spec = (
2981 rajveer 11906 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 11907 
  )
11908 
 
2981 rajveer 11909 
  def __init__(self, success=None,):
94 ashish 11910 
    self.success = success
11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
11921 
      if fid == 0:
2981 rajveer 11922 
        if ftype == TType.LIST:
11923 
          self.success = []
11924 
          (_etype117, _size114) = iprot.readListBegin()
11925 
          for _i118 in xrange(_size114):
11926 
            _elem119 = User()
11927 
            _elem119.read(iprot)
11928 
            self.success.append(_elem119)
11929 
          iprot.readListEnd()
94 ashish 11930 
        else:
11931 
          iprot.skip(ftype)
11932 
      else:
11933 
        iprot.skip(ftype)
11934 
      iprot.readFieldEnd()
11935 
    iprot.readStructEnd()
11936 
 
11937 
  def write(self, oprot):
11938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11940 
      return
2981 rajveer 11941 
    oprot.writeStructBegin('getAllUsers_result')
94 ashish 11942 
    if self.success != None:
2981 rajveer 11943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11945 
      for iter120 in self.success:
11946 
        iter120.write(oprot)
11947 
      oprot.writeListEnd()
94 ashish 11948 
      oprot.writeFieldEnd()
11949 
    oprot.writeFieldStop()
11950 
    oprot.writeStructEnd()
11951 
 
11952 
  def __repr__(self):
11953 
    L = ['%s=%r' % (key, value)
11954 
      for key, value in self.__dict__.iteritems()]
11955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11956 
 
11957 
  def __eq__(self, other):
11958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11959 
 
11960 
  def __ne__(self, other):
11961 
    return not (self == other)
11962 
 
2981 rajveer 11963 
class putUserNote_args:
130 ashish 11964 
  """
11965 
  Attributes:
2981 rajveer 11966 
   - user_id
11967 
   - entity_id
11968 
   - slide
11969 
   - note
130 ashish 11970 
  """
94 ashish 11971 
 
130 ashish 11972 
  thrift_spec = (
11973 
    None, # 0
2981 rajveer 11974 
    (1, TType.I64, 'user_id', None, None, ), # 1
11975 
    (2, TType.I64, 'entity_id', None, None, ), # 2
11976 
    (3, TType.STRING, 'slide', None, None, ), # 3
11977 
    (4, TType.STRING, 'note', None, None, ), # 4
130 ashish 11978 
  )
11979 
 
2981 rajveer 11980 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
11981 
    self.user_id = user_id
11982 
    self.entity_id = entity_id
11983 
    self.slide = slide
11984 
    self.note = note
130 ashish 11985 
 
11986 
  def read(self, iprot):
11987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11989 
      return
11990 
    iprot.readStructBegin()
11991 
    while True:
11992 
      (fname, ftype, fid) = iprot.readFieldBegin()
11993 
      if ftype == TType.STOP:
11994 
        break
11995 
      if fid == 1:
11996 
        if ftype == TType.I64:
2981 rajveer 11997 
          self.user_id = iprot.readI64();
130 ashish 11998 
        else:
11999 
          iprot.skip(ftype)
559 chandransh 12000 
      elif fid == 2:
12001 
        if ftype == TType.I64:
2981 rajveer 12002 
          self.entity_id = iprot.readI64();
559 chandransh 12003 
        else:
12004 
          iprot.skip(ftype)
2981 rajveer 12005 
      elif fid == 3:
12006 
        if ftype == TType.STRING:
12007 
          self.slide = iprot.readString();
12008 
        else:
12009 
          iprot.skip(ftype)
12010 
      elif fid == 4:
12011 
        if ftype == TType.STRING:
12012 
          self.note = iprot.readString();
12013 
        else:
12014 
          iprot.skip(ftype)
130 ashish 12015 
      else:
12016 
        iprot.skip(ftype)
12017 
      iprot.readFieldEnd()
12018 
    iprot.readStructEnd()
12019 
 
12020 
  def write(self, oprot):
12021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12023 
      return
2981 rajveer 12024 
    oprot.writeStructBegin('putUserNote_args')
12025 
    if self.user_id != None:
12026 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12027 
      oprot.writeI64(self.user_id)
130 ashish 12028 
      oprot.writeFieldEnd()
2981 rajveer 12029 
    if self.entity_id != None:
12030 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12031 
      oprot.writeI64(self.entity_id)
559 chandransh 12032 
      oprot.writeFieldEnd()
2981 rajveer 12033 
    if self.slide != None:
12034 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
12035 
      oprot.writeString(self.slide)
12036 
      oprot.writeFieldEnd()
12037 
    if self.note != None:
12038 
      oprot.writeFieldBegin('note', TType.STRING, 4)
12039 
      oprot.writeString(self.note)
12040 
      oprot.writeFieldEnd()
130 ashish 12041 
    oprot.writeFieldStop()
12042 
    oprot.writeStructEnd()
12043 
 
12044 
  def __repr__(self):
12045 
    L = ['%s=%r' % (key, value)
12046 
      for key, value in self.__dict__.iteritems()]
12047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12048 
 
12049 
  def __eq__(self, other):
12050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12051 
 
12052 
  def __ne__(self, other):
12053 
    return not (self == other)
12054 
 
2981 rajveer 12055 
class putUserNote_result:
559 chandransh 12056 
 
12057 
  thrift_spec = (
12058 
  )
12059 
 
12060 
  def read(self, iprot):
12061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12063 
      return
12064 
    iprot.readStructBegin()
12065 
    while True:
12066 
      (fname, ftype, fid) = iprot.readFieldBegin()
12067 
      if ftype == TType.STOP:
12068 
        break
12069 
      else:
12070 
        iprot.skip(ftype)
12071 
      iprot.readFieldEnd()
12072 
    iprot.readStructEnd()
12073 
 
12074 
  def write(self, oprot):
12075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12077 
      return
2981 rajveer 12078 
    oprot.writeStructBegin('putUserNote_result')
559 chandransh 12079 
    oprot.writeFieldStop()
12080 
    oprot.writeStructEnd()
12081 
 
12082 
  def __repr__(self):
12083 
    L = ['%s=%r' % (key, value)
12084 
      for key, value in self.__dict__.iteritems()]
12085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12086 
 
12087 
  def __eq__(self, other):
12088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12089 
 
12090 
  def __ne__(self, other):
12091 
    return not (self == other)
12092 
 
2981 rajveer 12093 
class getUserNotes_args:
559 chandransh 12094 
  """
12095 
  Attributes:
2981 rajveer 12096 
   - user_id
12097 
   - entity_id
559 chandransh 12098 
  """
12099 
 
12100 
  thrift_spec = (
12101 
    None, # 0
2981 rajveer 12102 
    (1, TType.I64, 'user_id', None, None, ), # 1
12103 
    (2, TType.I64, 'entity_id', None, None, ), # 2
559 chandransh 12104 
  )
12105 
 
2981 rajveer 12106 
  def __init__(self, user_id=None, entity_id=None,):
12107 
    self.user_id = user_id
12108 
    self.entity_id = entity_id
559 chandransh 12109 
 
12110 
  def read(self, iprot):
12111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12113 
      return
12114 
    iprot.readStructBegin()
12115 
    while True:
12116 
      (fname, ftype, fid) = iprot.readFieldBegin()
12117 
      if ftype == TType.STOP:
12118 
        break
12119 
      if fid == 1:
12120 
        if ftype == TType.I64:
2981 rajveer 12121 
          self.user_id = iprot.readI64();
559 chandransh 12122 
        else:
12123 
          iprot.skip(ftype)
12124 
      elif fid == 2:
12125 
        if ftype == TType.I64:
2981 rajveer 12126 
          self.entity_id = iprot.readI64();
559 chandransh 12127 
        else:
12128 
          iprot.skip(ftype)
12129 
      else:
12130 
        iprot.skip(ftype)
12131 
      iprot.readFieldEnd()
12132 
    iprot.readStructEnd()
12133 
 
12134 
  def write(self, oprot):
12135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12137 
      return
2981 rajveer 12138 
    oprot.writeStructBegin('getUserNotes_args')
12139 
    if self.user_id != None:
12140 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12141 
      oprot.writeI64(self.user_id)
559 chandransh 12142 
      oprot.writeFieldEnd()
2981 rajveer 12143 
    if self.entity_id != None:
12144 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12145 
      oprot.writeI64(self.entity_id)
559 chandransh 12146 
      oprot.writeFieldEnd()
12147 
    oprot.writeFieldStop()
12148 
    oprot.writeStructEnd()
12149 
 
12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
2981 rajveer 12161 
class getUserNotes_result:
12162 
  """
12163 
  Attributes:
12164 
   - success
12165 
  """
559 chandransh 12166 
 
12167 
  thrift_spec = (
2981 rajveer 12168 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
559 chandransh 12169 
  )
12170 
 
2981 rajveer 12171 
  def __init__(self, success=None,):
12172 
    self.success = success
12173 
 
559 chandransh 12174 
  def read(self, iprot):
12175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12177 
      return
12178 
    iprot.readStructBegin()
12179 
    while True:
12180 
      (fname, ftype, fid) = iprot.readFieldBegin()
12181 
      if ftype == TType.STOP:
12182 
        break
2981 rajveer 12183 
      if fid == 0:
12184 
        if ftype == TType.LIST:
12185 
          self.success = []
12186 
          (_etype124, _size121) = iprot.readListBegin()
12187 
          for _i125 in xrange(_size121):
12188 
            _elem126 = UserNote()
12189 
            _elem126.read(iprot)
12190 
            self.success.append(_elem126)
12191 
          iprot.readListEnd()
12192 
        else:
12193 
          iprot.skip(ftype)
559 chandransh 12194 
      else:
12195 
        iprot.skip(ftype)
12196 
      iprot.readFieldEnd()
12197 
    iprot.readStructEnd()
12198 
 
12199 
  def write(self, oprot):
12200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12202 
      return
2981 rajveer 12203 
    oprot.writeStructBegin('getUserNotes_result')
12204 
    if self.success != None:
12205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12207 
      for iter127 in self.success:
12208 
        iter127.write(oprot)
12209 
      oprot.writeListEnd()
12210 
      oprot.writeFieldEnd()
559 chandransh 12211 
    oprot.writeFieldStop()
12212 
    oprot.writeStructEnd()
12213 
 
12214 
  def __repr__(self):
12215 
    L = ['%s=%r' % (key, value)
12216 
      for key, value in self.__dict__.iteritems()]
12217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12218 
 
12219 
  def __eq__(self, other):
12220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12221 
 
12222 
  def __ne__(self, other):
12223 
    return not (self == other)
12224 
 
2981 rajveer 12225 
class getMyResearchItems_args:
559 chandransh 12226 
  """
12227 
  Attributes:
772 rajveer 12228 
   - userId
559 chandransh 12229 
  """
12230 
 
12231 
  thrift_spec = (
12232 
    None, # 0
772 rajveer 12233 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12234 
  )
12235 
 
772 rajveer 12236 
  def __init__(self, userId=None,):
12237 
    self.userId = userId
559 chandransh 12238 
 
12239 
  def read(self, iprot):
12240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12242 
      return
12243 
    iprot.readStructBegin()
12244 
    while True:
12245 
      (fname, ftype, fid) = iprot.readFieldBegin()
12246 
      if ftype == TType.STOP:
12247 
        break
12248 
      if fid == 1:
12249 
        if ftype == TType.I64:
772 rajveer 12250 
          self.userId = iprot.readI64();
559 chandransh 12251 
        else:
12252 
          iprot.skip(ftype)
12253 
      else:
12254 
        iprot.skip(ftype)
12255 
      iprot.readFieldEnd()
12256 
    iprot.readStructEnd()
12257 
 
12258 
  def write(self, oprot):
12259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12261 
      return
2981 rajveer 12262 
    oprot.writeStructBegin('getMyResearchItems_args')
772 rajveer 12263 
    if self.userId != None:
12264 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12265 
      oprot.writeI64(self.userId)
559 chandransh 12266 
      oprot.writeFieldEnd()
12267 
    oprot.writeFieldStop()
12268 
    oprot.writeStructEnd()
12269 
 
12270 
  def __repr__(self):
12271 
    L = ['%s=%r' % (key, value)
12272 
      for key, value in self.__dict__.iteritems()]
12273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12274 
 
12275 
  def __eq__(self, other):
12276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12277 
 
12278 
  def __ne__(self, other):
12279 
    return not (self == other)
12280 
 
2981 rajveer 12281 
class getMyResearchItems_result:
559 chandransh 12282 
  """
12283 
  Attributes:
130 ashish 12284 
   - success
559 chandransh 12285 
   - scx
130 ashish 12286 
  """
12287 
 
12288 
  thrift_spec = (
2981 rajveer 12289 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12290 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12291 
  )
12292 
 
559 chandransh 12293 
  def __init__(self, success=None, scx=None,):
130 ashish 12294 
    self.success = success
559 chandransh 12295 
    self.scx = scx
130 ashish 12296 
 
12297 
  def read(self, iprot):
12298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12300 
      return
12301 
    iprot.readStructBegin()
12302 
    while True:
12303 
      (fname, ftype, fid) = iprot.readFieldBegin()
12304 
      if ftype == TType.STOP:
12305 
        break
12306 
      if fid == 0:
2981 rajveer 12307 
        if ftype == TType.LIST:
12308 
          self.success = []
12309 
          (_etype131, _size128) = iprot.readListBegin()
12310 
          for _i132 in xrange(_size128):
12311 
            _elem133 = iprot.readI64();
12312 
            self.success.append(_elem133)
12313 
          iprot.readListEnd()
130 ashish 12314 
        else:
12315 
          iprot.skip(ftype)
12316 
      elif fid == 1:
12317 
        if ftype == TType.STRUCT:
559 chandransh 12318 
          self.scx = WidgetException()
12319 
          self.scx.read(iprot)
130 ashish 12320 
        else:
12321 
          iprot.skip(ftype)
12322 
      else:
12323 
        iprot.skip(ftype)
12324 
      iprot.readFieldEnd()
12325 
    iprot.readStructEnd()
12326 
 
12327 
  def write(self, oprot):
12328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12330 
      return
2981 rajveer 12331 
    oprot.writeStructBegin('getMyResearchItems_result')
130 ashish 12332 
    if self.success != None:
2981 rajveer 12333 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12334 
      oprot.writeListBegin(TType.I64, len(self.success))
12335 
      for iter134 in self.success:
12336 
        oprot.writeI64(iter134)
12337 
      oprot.writeListEnd()
130 ashish 12338 
      oprot.writeFieldEnd()
559 chandransh 12339 
    if self.scx != None:
12340 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12341 
      self.scx.write(oprot)
130 ashish 12342 
      oprot.writeFieldEnd()
12343 
    oprot.writeFieldStop()
12344 
    oprot.writeStructEnd()
12345 
 
12346 
  def __repr__(self):
12347 
    L = ['%s=%r' % (key, value)
12348 
      for key, value in self.__dict__.iteritems()]
12349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12350 
 
12351 
  def __eq__(self, other):
12352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12353 
 
12354 
  def __ne__(self, other):
12355 
    return not (self == other)
12356 
 
2981 rajveer 12357 
class updateMyResearch_args:
130 ashish 12358 
  """
12359 
  Attributes:
2981 rajveer 12360 
   - userId
12361 
   - itemId
130 ashish 12362 
  """
12363 
 
12364 
  thrift_spec = (
12365 
    None, # 0
2981 rajveer 12366 
    (1, TType.I64, 'userId', None, None, ), # 1
12367 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12368 
  )
12369 
 
2981 rajveer 12370 
  def __init__(self, userId=None, itemId=None,):
12371 
    self.userId = userId
12372 
    self.itemId = itemId
130 ashish 12373 
 
12374 
  def read(self, iprot):
12375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12377 
      return
12378 
    iprot.readStructBegin()
12379 
    while True:
12380 
      (fname, ftype, fid) = iprot.readFieldBegin()
12381 
      if ftype == TType.STOP:
12382 
        break
12383 
      if fid == 1:
559 chandransh 12384 
        if ftype == TType.I64:
2981 rajveer 12385 
          self.userId = iprot.readI64();
130 ashish 12386 
        else:
12387 
          iprot.skip(ftype)
12388 
      elif fid == 2:
559 chandransh 12389 
        if ftype == TType.I64:
2981 rajveer 12390 
          self.itemId = iprot.readI64();
559 chandransh 12391 
        else:
12392 
          iprot.skip(ftype)
130 ashish 12393 
      else:
12394 
        iprot.skip(ftype)
12395 
      iprot.readFieldEnd()
12396 
    iprot.readStructEnd()
12397 
 
12398 
  def write(self, oprot):
12399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12401 
      return
2981 rajveer 12402 
    oprot.writeStructBegin('updateMyResearch_args')
12403 
    if self.userId != None:
12404 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12405 
      oprot.writeI64(self.userId)
130 ashish 12406 
      oprot.writeFieldEnd()
2981 rajveer 12407 
    if self.itemId != None:
12408 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12409 
      oprot.writeI64(self.itemId)
130 ashish 12410 
      oprot.writeFieldEnd()
12411 
    oprot.writeFieldStop()
12412 
    oprot.writeStructEnd()
12413 
 
12414 
  def __repr__(self):
12415 
    L = ['%s=%r' % (key, value)
12416 
      for key, value in self.__dict__.iteritems()]
12417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12418 
 
12419 
  def __eq__(self, other):
12420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12421 
 
12422 
  def __ne__(self, other):
12423 
    return not (self == other)
12424 
 
2981 rajveer 12425 
class updateMyResearch_result:
12426 
  """
12427 
  Attributes:
12428 
   - success
12429 
   - scx
12430 
  """
559 chandransh 12431 
 
12432 
  thrift_spec = (
2981 rajveer 12433 
    (0, TType.BOOL, 'success', None, None, ), # 0
12434 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12435 
  )
12436 
 
2981 rajveer 12437 
  def __init__(self, success=None, scx=None,):
12438 
    self.success = success
12439 
    self.scx = scx
12440 
 
559 chandransh 12441 
  def read(self, iprot):
12442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12444 
      return
12445 
    iprot.readStructBegin()
12446 
    while True:
12447 
      (fname, ftype, fid) = iprot.readFieldBegin()
12448 
      if ftype == TType.STOP:
12449 
        break
2981 rajveer 12450 
      if fid == 0:
12451 
        if ftype == TType.BOOL:
12452 
          self.success = iprot.readBool();
12453 
        else:
12454 
          iprot.skip(ftype)
12455 
      elif fid == 1:
12456 
        if ftype == TType.STRUCT:
12457 
          self.scx = WidgetException()
12458 
          self.scx.read(iprot)
12459 
        else:
12460 
          iprot.skip(ftype)
559 chandransh 12461 
      else:
12462 
        iprot.skip(ftype)
12463 
      iprot.readFieldEnd()
12464 
    iprot.readStructEnd()
12465 
 
12466 
  def write(self, oprot):
12467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12469 
      return
2981 rajveer 12470 
    oprot.writeStructBegin('updateMyResearch_result')
12471 
    if self.success != None:
12472 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12473 
      oprot.writeBool(self.success)
12474 
      oprot.writeFieldEnd()
12475 
    if self.scx != None:
12476 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12477 
      self.scx.write(oprot)
12478 
      oprot.writeFieldEnd()
559 chandransh 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 
 
2981 rajveer 12493 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12494 
  """
12495 
  Attributes:
2981 rajveer 12496 
   - userId
12497 
   - itemId
1596 ankur.sing 12498 
  """
559 chandransh 12499 
 
1596 ankur.sing 12500 
  thrift_spec = (
12501 
    None, # 0
2981 rajveer 12502 
    (1, TType.I64, 'userId', None, None, ), # 1
12503 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12504 
  )
12505 
 
2981 rajveer 12506 
  def __init__(self, userId=None, itemId=None,):
12507 
    self.userId = userId
12508 
    self.itemId = itemId
1596 ankur.sing 12509 
 
12510 
  def read(self, iprot):
12511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12513 
      return
12514 
    iprot.readStructBegin()
12515 
    while True:
12516 
      (fname, ftype, fid) = iprot.readFieldBegin()
12517 
      if ftype == TType.STOP:
12518 
        break
12519 
      if fid == 1:
2981 rajveer 12520 
        if ftype == TType.I64:
12521 
          self.userId = iprot.readI64();
1596 ankur.sing 12522 
        else:
12523 
          iprot.skip(ftype)
2981 rajveer 12524 
      elif fid == 2:
12525 
        if ftype == TType.I64:
12526 
          self.itemId = iprot.readI64();
12527 
        else:
12528 
          iprot.skip(ftype)
1596 ankur.sing 12529 
      else:
12530 
        iprot.skip(ftype)
12531 
      iprot.readFieldEnd()
12532 
    iprot.readStructEnd()
12533 
 
12534 
  def write(self, oprot):
12535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12537 
      return
2981 rajveer 12538 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
12539 
    if self.userId != None:
12540 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12541 
      oprot.writeI64(self.userId)
1596 ankur.sing 12542 
      oprot.writeFieldEnd()
2981 rajveer 12543 
    if self.itemId != None:
12544 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12545 
      oprot.writeI64(self.itemId)
12546 
      oprot.writeFieldEnd()
1596 ankur.sing 12547 
    oprot.writeFieldStop()
12548 
    oprot.writeStructEnd()
12549 
 
12550 
  def __repr__(self):
12551 
    L = ['%s=%r' % (key, value)
12552 
      for key, value in self.__dict__.iteritems()]
12553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12554 
 
12555 
  def __eq__(self, other):
12556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12557 
 
12558 
  def __ne__(self, other):
12559 
    return not (self == other)
12560 
 
2981 rajveer 12561 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12562 
  """
12563 
  Attributes:
2981 rajveer 12564 
   - scx
1596 ankur.sing 12565 
  """
12566 
 
12567 
  thrift_spec = (
2981 rajveer 12568 
    None, # 0
12569 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12570 
  )
12571 
 
2981 rajveer 12572 
  def __init__(self, scx=None,):
12573 
    self.scx = scx
1596 ankur.sing 12574 
 
12575 
  def read(self, iprot):
12576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12578 
      return
12579 
    iprot.readStructBegin()
12580 
    while True:
12581 
      (fname, ftype, fid) = iprot.readFieldBegin()
12582 
      if ftype == TType.STOP:
12583 
        break
2981 rajveer 12584 
      if fid == 1:
12585 
        if ftype == TType.STRUCT:
12586 
          self.scx = WidgetException()
12587 
          self.scx.read(iprot)
1596 ankur.sing 12588 
        else:
12589 
          iprot.skip(ftype)
12590 
      else:
12591 
        iprot.skip(ftype)
12592 
      iprot.readFieldEnd()
12593 
    iprot.readStructEnd()
12594 
 
12595 
  def write(self, oprot):
12596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12598 
      return
2981 rajveer 12599 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12600 
    if self.scx != None:
12601 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12602 
      self.scx.write(oprot)
1596 ankur.sing 12603 
      oprot.writeFieldEnd()
12604 
    oprot.writeFieldStop()
12605 
    oprot.writeStructEnd()
12606 
 
12607 
  def __repr__(self):
12608 
    L = ['%s=%r' % (key, value)
12609 
      for key, value in self.__dict__.iteritems()]
12610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12611 
 
12612 
  def __eq__(self, other):
12613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12614 
 
12615 
  def __ne__(self, other):
12616 
    return not (self == other)
12617 
 
2981 rajveer 12618 
class getBrowseHistoryItems_args:
1673 ankur.sing 12619 
  """
12620 
  Attributes:
2981 rajveer 12621 
   - userId
1673 ankur.sing 12622 
  """
1596 ankur.sing 12623 
 
1673 ankur.sing 12624 
  thrift_spec = (
12625 
    None, # 0
2981 rajveer 12626 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12627 
  )
12628 
 
2981 rajveer 12629 
  def __init__(self, userId=None,):
12630 
    self.userId = userId
1673 ankur.sing 12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 1:
1891 ankur.sing 12642 
        if ftype == TType.I64:
2981 rajveer 12643 
          self.userId = iprot.readI64();
1891 ankur.sing 12644 
        else:
12645 
          iprot.skip(ftype)
1673 ankur.sing 12646 
      else:
12647 
        iprot.skip(ftype)
12648 
      iprot.readFieldEnd()
12649 
    iprot.readStructEnd()
12650 
 
12651 
  def write(self, oprot):
12652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12654 
      return
2981 rajveer 12655 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
12656 
    if self.userId != None:
12657 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12658 
      oprot.writeI64(self.userId)
1673 ankur.sing 12659 
      oprot.writeFieldEnd()
12660 
    oprot.writeFieldStop()
12661 
    oprot.writeStructEnd()
12662 
 
12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
2981 rajveer 12674 
class getBrowseHistoryItems_result:
1673 ankur.sing 12675 
  """
12676 
  Attributes:
12677 
   - success
2981 rajveer 12678 
   - scx
1673 ankur.sing 12679 
  """
12680 
 
12681 
  thrift_spec = (
2981 rajveer 12682 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12683 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12684 
  )
12685 
 
2981 rajveer 12686 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12687 
    self.success = success
2981 rajveer 12688 
    self.scx = scx
1673 ankur.sing 12689 
 
12690 
  def read(self, iprot):
12691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12693 
      return
12694 
    iprot.readStructBegin()
12695 
    while True:
12696 
      (fname, ftype, fid) = iprot.readFieldBegin()
12697 
      if ftype == TType.STOP:
12698 
        break
12699 
      if fid == 0:
12700 
        if ftype == TType.LIST:
12701 
          self.success = []
2981 rajveer 12702 
          (_etype138, _size135) = iprot.readListBegin()
12703 
          for _i139 in xrange(_size135):
12704 
            _elem140 = iprot.readI64();
12705 
            self.success.append(_elem140)
1673 ankur.sing 12706 
          iprot.readListEnd()
12707 
        else:
12708 
          iprot.skip(ftype)
2981 rajveer 12709 
      elif fid == 1:
12710 
        if ftype == TType.STRUCT:
12711 
          self.scx = WidgetException()
12712 
          self.scx.read(iprot)
12713 
        else:
12714 
          iprot.skip(ftype)
1673 ankur.sing 12715 
      else:
12716 
        iprot.skip(ftype)
12717 
      iprot.readFieldEnd()
12718 
    iprot.readStructEnd()
12719 
 
12720 
  def write(self, oprot):
12721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12723 
      return
2981 rajveer 12724 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
1673 ankur.sing 12725 
    if self.success != None:
12726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12727 
      oprot.writeListBegin(TType.I64, len(self.success))
12728 
      for iter141 in self.success:
12729 
        oprot.writeI64(iter141)
1673 ankur.sing 12730 
      oprot.writeListEnd()
12731 
      oprot.writeFieldEnd()
2981 rajveer 12732 
    if self.scx != None:
12733 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12734 
      self.scx.write(oprot)
2642 varun.gupt 12735 
      oprot.writeFieldEnd()
12736 
    oprot.writeFieldStop()
12737 
    oprot.writeStructEnd()
12738 
 
12739 
  def __repr__(self):
12740 
    L = ['%s=%r' % (key, value)
12741 
      for key, value in self.__dict__.iteritems()]
12742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12743 
 
12744 
  def __eq__(self, other):
12745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12746 
 
12747 
  def __ne__(self, other):
12748 
    return not (self == other)
12749 
 
2981 rajveer 12750 
class updateBrowseHistory_args:
2642 varun.gupt 12751 
  """
12752 
  Attributes:
2981 rajveer 12753 
   - userId
12754 
   - itemId
2642 varun.gupt 12755 
  """
12756 
 
12757 
  thrift_spec = (
12758 
    None, # 0
2981 rajveer 12759 
    (1, TType.I64, 'userId', None, None, ), # 1
12760 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12761 
  )
12762 
 
2981 rajveer 12763 
  def __init__(self, userId=None, itemId=None,):
12764 
    self.userId = userId
12765 
    self.itemId = itemId
2642 varun.gupt 12766 
 
12767 
  def read(self, iprot):
12768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12770 
      return
12771 
    iprot.readStructBegin()
12772 
    while True:
12773 
      (fname, ftype, fid) = iprot.readFieldBegin()
12774 
      if ftype == TType.STOP:
12775 
        break
12776 
      if fid == 1:
12777 
        if ftype == TType.I64:
2981 rajveer 12778 
          self.userId = iprot.readI64();
2642 varun.gupt 12779 
        else:
12780 
          iprot.skip(ftype)
12781 
      elif fid == 2:
12782 
        if ftype == TType.I64:
2981 rajveer 12783 
          self.itemId = iprot.readI64();
2642 varun.gupt 12784 
        else:
12785 
          iprot.skip(ftype)
12786 
      else:
12787 
        iprot.skip(ftype)
12788 
      iprot.readFieldEnd()
12789 
    iprot.readStructEnd()
12790 
 
12791 
  def write(self, oprot):
12792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12794 
      return
2981 rajveer 12795 
    oprot.writeStructBegin('updateBrowseHistory_args')
12796 
    if self.userId != None:
12797 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12798 
      oprot.writeI64(self.userId)
2642 varun.gupt 12799 
      oprot.writeFieldEnd()
2981 rajveer 12800 
    if self.itemId != None:
12801 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12802 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12803 
      oprot.writeFieldEnd()
12804 
    oprot.writeFieldStop()
12805 
    oprot.writeStructEnd()
12806 
 
12807 
  def __repr__(self):
12808 
    L = ['%s=%r' % (key, value)
12809 
      for key, value in self.__dict__.iteritems()]
12810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12811 
 
12812 
  def __eq__(self, other):
12813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12814 
 
12815 
  def __ne__(self, other):
12816 
    return not (self == other)
12817 
 
2981 rajveer 12818 
class updateBrowseHistory_result:
2642 varun.gupt 12819 
 
12820 
  thrift_spec = (
12821 
  )
12822 
 
12823 
  def read(self, iprot):
12824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12826 
      return
12827 
    iprot.readStructBegin()
12828 
    while True:
12829 
      (fname, ftype, fid) = iprot.readFieldBegin()
12830 
      if ftype == TType.STOP:
12831 
        break
12832 
      else:
12833 
        iprot.skip(ftype)
12834 
      iprot.readFieldEnd()
12835 
    iprot.readStructEnd()
12836 
 
12837 
  def write(self, oprot):
12838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12840 
      return
2981 rajveer 12841 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12842 
    oprot.writeFieldStop()
12843 
    oprot.writeStructEnd()
12844 
 
12845 
  def __repr__(self):
12846 
    L = ['%s=%r' % (key, value)
12847 
      for key, value in self.__dict__.iteritems()]
12848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12849 
 
12850 
  def __eq__(self, other):
12851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12852 
 
12853 
  def __ne__(self, other):
12854 
    return not (self == other)
12855 
 
12856