Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
12722 amit.gupta 713 
  def getAllUsersByCounter(self, counterId):
714 
    """
715 
    Parameters:
716 
     - counterId
717 
    """
718 
    pass
719 
 
15251 manish.sha 720 
  def getActiveAccessTokenForUser(self, userId, source):
721 
    """
722 
    Parameters:
723 
     - userId
724 
     - source
725 
    """
726 
    pass
12722 amit.gupta 727 
 
15251 manish.sha 728 
  def validateAccessToken(self, accessToken):
729 
    """
730 
    Parameters:
731 
     - accessToken
732 
    """
733 
    pass
734 
 
735 
 
3376 rajveer 736 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 737 
  """
738 
  service
739 
  """
740 
  def __init__(self, iprot, oprot=None):
3376 rajveer 741 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 742 
 
559 chandransh 743 
  def createAnonymousUser(self, jsessionId):
94 ashish 744 
    """
745 
    Parameters:
559 chandransh 746 
     - jsessionId
94 ashish 747 
    """
559 chandransh 748 
    self.send_createAnonymousUser(jsessionId)
749 
    return self.recv_createAnonymousUser()
94 ashish 750 
 
559 chandransh 751 
  def send_createAnonymousUser(self, jsessionId):
752 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
753 
    args = createAnonymousUser_args()
754 
    args.jsessionId = jsessionId
94 ashish 755 
    args.write(self._oprot)
756 
    self._oprot.writeMessageEnd()
757 
    self._oprot.trans.flush()
758 
 
559 chandransh 759 
  def recv_createAnonymousUser(self, ):
94 ashish 760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
761 
    if mtype == TMessageType.EXCEPTION:
762 
      x = TApplicationException()
763 
      x.read(self._iprot)
764 
      self._iprot.readMessageEnd()
765 
      raise x
559 chandransh 766 
    result = createAnonymousUser_result()
94 ashish 767 
    result.read(self._iprot)
768 
    self._iprot.readMessageEnd()
3431 rajveer 769 
    if result.success is not None:
94 ashish 770 
      return result.success
3431 rajveer 771 
    if result.ucex is not None:
559 chandransh 772 
      raise result.ucex
773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 774 
 
559 chandransh 775 
  def getUserById(self, userId):
94 ashish 776 
    """
777 
    Parameters:
778 
     - userId
779 
    """
559 chandransh 780 
    self.send_getUserById(userId)
781 
    return self.recv_getUserById()
94 ashish 782 
 
559 chandransh 783 
  def send_getUserById(self, userId):
784 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
785 
    args = getUserById_args()
94 ashish 786 
    args.userId = userId
787 
    args.write(self._oprot)
788 
    self._oprot.writeMessageEnd()
789 
    self._oprot.trans.flush()
790 
 
559 chandransh 791 
  def recv_getUserById(self, ):
94 ashish 792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
793 
    if mtype == TMessageType.EXCEPTION:
794 
      x = TApplicationException()
795 
      x.read(self._iprot)
796 
      self._iprot.readMessageEnd()
797 
      raise x
559 chandransh 798 
    result = getUserById_result()
94 ashish 799 
    result.read(self._iprot)
800 
    self._iprot.readMessageEnd()
3431 rajveer 801 
    if result.success is not None:
94 ashish 802 
      return result.success
3431 rajveer 803 
    if result.ucex is not None:
559 chandransh 804 
      raise result.ucex
805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 806 
 
5326 rajveer 807 
  def getUserByCartId(self, cartId):
808 
    """
809 
    Parameters:
810 
     - cartId
811 
    """
812 
    self.send_getUserByCartId(cartId)
813 
    return self.recv_getUserByCartId()
814 
 
815 
  def send_getUserByCartId(self, cartId):
816 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
817 
    args = getUserByCartId_args()
818 
    args.cartId = cartId
819 
    args.write(self._oprot)
820 
    self._oprot.writeMessageEnd()
821 
    self._oprot.trans.flush()
822 
 
823 
  def recv_getUserByCartId(self, ):
824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
825 
    if mtype == TMessageType.EXCEPTION:
826 
      x = TApplicationException()
827 
      x.read(self._iprot)
828 
      self._iprot.readMessageEnd()
829 
      raise x
830 
    result = getUserByCartId_result()
831 
    result.read(self._iprot)
832 
    self._iprot.readMessageEnd()
833 
    if result.success is not None:
834 
      return result.success
835 
    if result.ucex is not None:
836 
      raise result.ucex
837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
838 
 
1491 vikas 839 
  def getUserByEmail(self, email):
840 
    """
841 
    Parameters:
842 
     - email
843 
    """
844 
    self.send_getUserByEmail(email)
845 
    return self.recv_getUserByEmail()
846 
 
847 
  def send_getUserByEmail(self, email):
848 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
849 
    args = getUserByEmail_args()
850 
    args.email = email
851 
    args.write(self._oprot)
852 
    self._oprot.writeMessageEnd()
853 
    self._oprot.trans.flush()
854 
 
855 
  def recv_getUserByEmail(self, ):
856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
857 
    if mtype == TMessageType.EXCEPTION:
858 
      x = TApplicationException()
859 
      x.read(self._iprot)
860 
      self._iprot.readMessageEnd()
861 
      raise x
862 
    result = getUserByEmail_result()
863 
    result.read(self._iprot)
864 
    self._iprot.readMessageEnd()
3431 rajveer 865 
    if result.success is not None:
1491 vikas 866 
      return result.success
3431 rajveer 867 
    if result.ucex is not None:
1491 vikas 868 
      raise result.ucex
869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
870 
 
3032 mandeep.dh 871 
  def getUserByMobileNumber(self, mobileNumber):
872 
    """
873 
    Parameters:
874 
     - mobileNumber
875 
    """
876 
    self.send_getUserByMobileNumber(mobileNumber)
877 
    return self.recv_getUserByMobileNumber()
878 
 
879 
  def send_getUserByMobileNumber(self, mobileNumber):
880 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
881 
    args = getUserByMobileNumber_args()
882 
    args.mobileNumber = mobileNumber
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getUserByMobileNumber(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getUserByMobileNumber_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
3431 rajveer 897 
    if result.success is not None:
3032 mandeep.dh 898 
      return result.success
3431 rajveer 899 
    if result.ucex is not None:
3032 mandeep.dh 900 
      raise result.ucex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
902 
 
559 chandransh 903 
  def createUser(self, user):
94 ashish 904 
    """
905 
    Parameters:
559 chandransh 906 
     - user
94 ashish 907 
    """
559 chandransh 908 
    self.send_createUser(user)
909 
    return self.recv_createUser()
94 ashish 910 
 
559 chandransh 911 
  def send_createUser(self, user):
912 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
913 
    args = createUser_args()
914 
    args.user = user
94 ashish 915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
559 chandransh 919 
  def recv_createUser(self, ):
94 ashish 920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
559 chandransh 926 
    result = createUser_result()
94 ashish 927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
3431 rajveer 929 
    if result.success is not None:
94 ashish 930 
      return result.success
3431 rajveer 931 
    if result.ucex is not None:
559 chandransh 932 
      raise result.ucex
933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 934 
 
559 chandransh 935 
  def updateUser(self, user):
94 ashish 936 
    """
937 
    Parameters:
559 chandransh 938 
     - user
94 ashish 939 
    """
559 chandransh 940 
    self.send_updateUser(user)
941 
    return self.recv_updateUser()
94 ashish 942 
 
559 chandransh 943 
  def send_updateUser(self, user):
944 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
945 
    args = updateUser_args()
946 
    args.user = user
94 ashish 947 
    args.write(self._oprot)
948 
    self._oprot.writeMessageEnd()
949 
    self._oprot.trans.flush()
950 
 
559 chandransh 951 
  def recv_updateUser(self, ):
94 ashish 952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
953 
    if mtype == TMessageType.EXCEPTION:
954 
      x = TApplicationException()
955 
      x.read(self._iprot)
956 
      self._iprot.readMessageEnd()
957 
      raise x
559 chandransh 958 
    result = updateUser_result()
94 ashish 959 
    result.read(self._iprot)
960 
    self._iprot.readMessageEnd()
3431 rajveer 961 
    if result.success is not None:
94 ashish 962 
      return result.success
3431 rajveer 963 
    if result.ucex is not None:
559 chandransh 964 
      raise result.ucex
965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 966 
 
559 chandransh 967 
  def authenticateUser(self, email, password):
94 ashish 968 
    """
969 
    Parameters:
970 
     - email
971 
     - password
972 
    """
559 chandransh 973 
    self.send_authenticateUser(email, password)
122 ashish 974 
    return self.recv_authenticateUser()
975 
 
559 chandransh 976 
  def send_authenticateUser(self, email, password):
122 ashish 977 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
978 
    args = authenticateUser_args()
559 chandransh 979 
    args.email = email
122 ashish 980 
    args.password = password
981 
    args.write(self._oprot)
982 
    self._oprot.writeMessageEnd()
983 
    self._oprot.trans.flush()
984 
 
985 
  def recv_authenticateUser(self, ):
986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
987 
    if mtype == TMessageType.EXCEPTION:
988 
      x = TApplicationException()
989 
      x.read(self._iprot)
990 
      self._iprot.readMessageEnd()
991 
      raise x
992 
    result = authenticateUser_result()
993 
    result.read(self._iprot)
994 
    self._iprot.readMessageEnd()
3431 rajveer 995 
    if result.success is not None:
122 ashish 996 
      return result.success
3431 rajveer 997 
    if result.auex is not None:
559 chandransh 998 
      raise result.auex
122 ashish 999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1000 
 
94 ashish 1001 
  def userExists(self, email):
1002 
    """
1003 
    Parameters:
1004 
     - email
1005 
    """
1006 
    self.send_userExists(email)
1007 
    return self.recv_userExists()
1008 
 
1009 
  def send_userExists(self, email):
1010 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1011 
    args = userExists_args()
1012 
    args.email = email
1013 
    args.write(self._oprot)
1014 
    self._oprot.writeMessageEnd()
1015 
    self._oprot.trans.flush()
1016 
 
1017 
  def recv_userExists(self, ):
1018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1019 
    if mtype == TMessageType.EXCEPTION:
1020 
      x = TApplicationException()
1021 
      x.read(self._iprot)
1022 
      self._iprot.readMessageEnd()
1023 
      raise x
1024 
    result = userExists_result()
1025 
    result.read(self._iprot)
1026 
    self._iprot.readMessageEnd()
3431 rajveer 1027 
    if result.success is not None:
94 ashish 1028 
      return result.success
3431 rajveer 1029 
    if result.ucx is not None:
94 ashish 1030 
      raise result.ucx
1031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1032 
 
567 rajveer 1033 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1034 
    """
1035 
    Parameters:
1036 
     - userId
1037 
     - address
513 rajveer 1038 
     - setDefault
94 ashish 1039 
    """
567 rajveer 1040 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1041 
    return self.recv_addAddressForUser()
1042 
 
567 rajveer 1043 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1044 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1045 
    args = addAddressForUser_args()
559 chandransh 1046 
    args.userId = userId
94 ashish 1047 
    args.address = address
513 rajveer 1048 
    args.setDefault = setDefault
94 ashish 1049 
    args.write(self._oprot)
1050 
    self._oprot.writeMessageEnd()
1051 
    self._oprot.trans.flush()
1052 
 
1053 
  def recv_addAddressForUser(self, ):
1054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1055 
    if mtype == TMessageType.EXCEPTION:
1056 
      x = TApplicationException()
1057 
      x.read(self._iprot)
1058 
      self._iprot.readMessageEnd()
1059 
      raise x
1060 
    result = addAddressForUser_result()
1061 
    result.read(self._iprot)
1062 
    self._iprot.readMessageEnd()
3431 rajveer 1063 
    if result.success is not None:
94 ashish 1064 
      return result.success
3431 rajveer 1065 
    if result.ucx is not None:
94 ashish 1066 
      raise result.ucx
1067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1068 
 
1069 
  def removeAddressForUser(self, userid, addressId):
1070 
    """
1071 
    Parameters:
1072 
     - userid
1073 
     - addressId
1074 
    """
1075 
    self.send_removeAddressForUser(userid, addressId)
1076 
    return self.recv_removeAddressForUser()
1077 
 
1078 
  def send_removeAddressForUser(self, userid, addressId):
1079 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1080 
    args = removeAddressForUser_args()
1081 
    args.userid = userid
1082 
    args.addressId = addressId
1083 
    args.write(self._oprot)
1084 
    self._oprot.writeMessageEnd()
1085 
    self._oprot.trans.flush()
1086 
 
1087 
  def recv_removeAddressForUser(self, ):
1088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1089 
    if mtype == TMessageType.EXCEPTION:
1090 
      x = TApplicationException()
1091 
      x.read(self._iprot)
1092 
      self._iprot.readMessageEnd()
1093 
      raise x
1094 
    result = removeAddressForUser_result()
1095 
    result.read(self._iprot)
1096 
    self._iprot.readMessageEnd()
3431 rajveer 1097 
    if result.success is not None:
94 ashish 1098 
      return result.success
3431 rajveer 1099 
    if result.ucx is not None:
94 ashish 1100 
      raise result.ucx
1101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1102 
 
1103 
  def setUserAsLoggedIn(self, userId, timestamp):
1104 
    """
1105 
    Parameters:
1106 
     - userId
1107 
     - timestamp
1108 
    """
1109 
    self.send_setUserAsLoggedIn(userId, timestamp)
1110 
    return self.recv_setUserAsLoggedIn()
1111 
 
1112 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1113 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1114 
    args = setUserAsLoggedIn_args()
1115 
    args.userId = userId
1116 
    args.timestamp = timestamp
1117 
    args.write(self._oprot)
1118 
    self._oprot.writeMessageEnd()
1119 
    self._oprot.trans.flush()
1120 
 
1121 
  def recv_setUserAsLoggedIn(self, ):
1122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1123 
    if mtype == TMessageType.EXCEPTION:
1124 
      x = TApplicationException()
1125 
      x.read(self._iprot)
1126 
      self._iprot.readMessageEnd()
1127 
      raise x
1128 
    result = setUserAsLoggedIn_result()
1129 
    result.read(self._iprot)
1130 
    self._iprot.readMessageEnd()
3431 rajveer 1131 
    if result.success is not None:
94 ashish 1132 
      return result.success
3431 rajveer 1133 
    if result.ucx is not None:
94 ashish 1134 
      raise result.ucx
1135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1136 
 
1137 
  def setUserAsLoggedOut(self, userid, timestamp):
1138 
    """
1139 
    Parameters:
1140 
     - userid
1141 
     - timestamp
1142 
    """
1143 
    self.send_setUserAsLoggedOut(userid, timestamp)
1144 
    return self.recv_setUserAsLoggedOut()
1145 
 
1146 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1147 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1148 
    args = setUserAsLoggedOut_args()
1149 
    args.userid = userid
1150 
    args.timestamp = timestamp
1151 
    args.write(self._oprot)
1152 
    self._oprot.writeMessageEnd()
1153 
    self._oprot.trans.flush()
1154 
 
1155 
  def recv_setUserAsLoggedOut(self, ):
1156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1157 
    if mtype == TMessageType.EXCEPTION:
1158 
      x = TApplicationException()
1159 
      x.read(self._iprot)
1160 
      self._iprot.readMessageEnd()
1161 
      raise x
1162 
    result = setUserAsLoggedOut_result()
1163 
    result.read(self._iprot)
1164 
    self._iprot.readMessageEnd()
3431 rajveer 1165 
    if result.success is not None:
94 ashish 1166 
      return result.success
3431 rajveer 1167 
    if result.ucx is not None:
94 ashish 1168 
      raise result.ucx
1169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1170 
 
504 rajveer 1171 
  def setDefaultAddress(self, userid, addressId):
1172 
    """
1173 
    Parameters:
1174 
     - userid
1175 
     - addressId
1176 
    """
1177 
    self.send_setDefaultAddress(userid, addressId)
1178 
    return self.recv_setDefaultAddress()
1179 
 
1180 
  def send_setDefaultAddress(self, userid, addressId):
1181 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1182 
    args = setDefaultAddress_args()
1183 
    args.userid = userid
1184 
    args.addressId = addressId
1185 
    args.write(self._oprot)
1186 
    self._oprot.writeMessageEnd()
1187 
    self._oprot.trans.flush()
1188 
 
1189 
  def recv_setDefaultAddress(self, ):
1190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1191 
    if mtype == TMessageType.EXCEPTION:
1192 
      x = TApplicationException()
1193 
      x.read(self._iprot)
1194 
      self._iprot.readMessageEnd()
1195 
      raise x
1196 
    result = setDefaultAddress_result()
1197 
    result.read(self._iprot)
1198 
    self._iprot.readMessageEnd()
3431 rajveer 1199 
    if result.success is not None:
504 rajveer 1200 
      return result.success
3431 rajveer 1201 
    if result.ucx is not None:
504 rajveer 1202 
      raise result.ucx
1203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1204 
 
594 rajveer 1205 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1206 
    """
1207 
    Parameters:
1208 
     - userid
594 rajveer 1209 
     - oldPassword
1210 
     - newPassword
94 ashish 1211 
    """
594 rajveer 1212 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1213 
    return self.recv_updatePassword()
1214 
 
594 rajveer 1215 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1216 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1217 
    args = updatePassword_args()
1218 
    args.userid = userid
594 rajveer 1219 
    args.oldPassword = oldPassword
1220 
    args.newPassword = newPassword
94 ashish 1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_updatePassword(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = updatePassword_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
3431 rajveer 1235 
    if result.success is not None:
94 ashish 1236 
      return result.success
3431 rajveer 1237 
    if result.ucx is not None:
94 ashish 1238 
      raise result.ucx
1239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1240 
 
884 rajveer 1241 
  def forgotPassword(self, email, newPassword):
581 rajveer 1242 
    """
1243 
    Parameters:
1244 
     - email
884 rajveer 1245 
     - newPassword
581 rajveer 1246 
    """
884 rajveer 1247 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1248 
    return self.recv_forgotPassword()
1249 
 
884 rajveer 1250 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1251 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1252 
    args = forgotPassword_args()
1253 
    args.email = email
884 rajveer 1254 
    args.newPassword = newPassword
581 rajveer 1255 
    args.write(self._oprot)
1256 
    self._oprot.writeMessageEnd()
1257 
    self._oprot.trans.flush()
1258 
 
1259 
  def recv_forgotPassword(self, ):
1260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1261 
    if mtype == TMessageType.EXCEPTION:
1262 
      x = TApplicationException()
1263 
      x.read(self._iprot)
1264 
      self._iprot.readMessageEnd()
1265 
      raise x
1266 
    result = forgotPassword_result()
1267 
    result.read(self._iprot)
1268 
    self._iprot.readMessageEnd()
3431 rajveer 1269 
    if result.success is not None:
581 rajveer 1270 
      return result.success
3431 rajveer 1271 
    if result.ucx is not None:
581 rajveer 1272 
      raise result.ucx
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1274 
 
594 rajveer 1275 
  def getAllAddressesForUser(self, userId):
1276 
    """
1277 
    Parameters:
1278 
     - userId
1279 
    """
1280 
    self.send_getAllAddressesForUser(userId)
1281 
    return self.recv_getAllAddressesForUser()
1282 
 
1283 
  def send_getAllAddressesForUser(self, userId):
1284 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1285 
    args = getAllAddressesForUser_args()
1286 
    args.userId = userId
1287 
    args.write(self._oprot)
1288 
    self._oprot.writeMessageEnd()
1289 
    self._oprot.trans.flush()
1290 
 
1291 
  def recv_getAllAddressesForUser(self, ):
1292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1293 
    if mtype == TMessageType.EXCEPTION:
1294 
      x = TApplicationException()
1295 
      x.read(self._iprot)
1296 
      self._iprot.readMessageEnd()
1297 
      raise x
1298 
    result = getAllAddressesForUser_result()
1299 
    result.read(self._iprot)
1300 
    self._iprot.readMessageEnd()
3431 rajveer 1301 
    if result.success is not None:
594 rajveer 1302 
      return result.success
3431 rajveer 1303 
    if result.ucx is not None:
594 rajveer 1304 
      raise result.ucx
1305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1306 
 
1894 vikas 1307 
  def getAddressById(self, addressId):
1308 
    """
1309 
    Parameters:
1310 
     - addressId
1311 
    """
1312 
    self.send_getAddressById(addressId)
1313 
    return self.recv_getAddressById()
1314 
 
1315 
  def send_getAddressById(self, addressId):
1316 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1317 
    args = getAddressById_args()
1318 
    args.addressId = addressId
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1323 
  def recv_getAddressById(self, ):
1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1330 
    result = getAddressById_result()
1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
1894 vikas 1334 
      return result.success
3431 rajveer 1335 
    if result.ucx is not None:
1894 vikas 1336 
      raise result.ucx
1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1338 
 
594 rajveer 1339 
  def getDefaultAddressId(self, userId):
1340 
    """
1341 
    Parameters:
1342 
     - userId
1343 
    """
1344 
    self.send_getDefaultAddressId(userId)
1345 
    return self.recv_getDefaultAddressId()
1346 
 
1347 
  def send_getDefaultAddressId(self, userId):
1348 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1349 
    args = getDefaultAddressId_args()
1350 
    args.userId = userId
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1355 
  def recv_getDefaultAddressId(self, ):
1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1362 
    result = getDefaultAddressId_result()
1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
3431 rajveer 1365 
    if result.success is not None:
594 rajveer 1366 
      return result.success
3431 rajveer 1367 
    if result.ucx is not None:
594 rajveer 1368 
      raise result.ucx
1369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1370 
 
785 rajveer 1371 
  def getDefaultPincode(self, userId):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
    """
1376 
    self.send_getDefaultPincode(userId)
1377 
    return self.recv_getDefaultPincode()
1378 
 
1379 
  def send_getDefaultPincode(self, userId):
1380 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1381 
    args = getDefaultPincode_args()
1382 
    args.userId = userId
1383 
    args.write(self._oprot)
1384 
    self._oprot.writeMessageEnd()
1385 
    self._oprot.trans.flush()
1386 
 
1387 
  def recv_getDefaultPincode(self, ):
1388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1389 
    if mtype == TMessageType.EXCEPTION:
1390 
      x = TApplicationException()
1391 
      x.read(self._iprot)
1392 
      self._iprot.readMessageEnd()
1393 
      raise x
1394 
    result = getDefaultPincode_result()
1395 
    result.read(self._iprot)
1396 
    self._iprot.readMessageEnd()
3431 rajveer 1397 
    if result.success is not None:
785 rajveer 1398 
      return result.success
3431 rajveer 1399 
    if result.ucx is not None:
785 rajveer 1400 
      raise result.ucx
1401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1402 
 
1274 varun.gupt 1403 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1404 
    """
1405 
    Parameters:
1406 
     - userId
1407 
     - replyTo
1408 
     - communicationType
1409 
     - orderId
1410 
     - airwaybillNo
1411 
     - productName
1412 
     - subject
1413 
     - message
1414 
    """
1415 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1416 
    return self.recv_saveUserCommunication()
1417 
 
1418 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1419 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1420 
    args = saveUserCommunication_args()
1421 
    args.userId = userId
1422 
    args.replyTo = replyTo
1423 
    args.communicationType = communicationType
1424 
    args.orderId = orderId
1425 
    args.airwaybillNo = airwaybillNo
1426 
    args.productName = productName
1427 
    args.subject = subject
1428 
    args.message = message
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_saveUserCommunication(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = saveUserCommunication_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
3431 rajveer 1443 
    if result.success is not None:
1274 varun.gupt 1444 
      return result.success
3431 rajveer 1445 
    if result.ucx is not None:
1274 varun.gupt 1446 
      raise result.ucx
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1448 
 
1590 varun.gupt 1449 
  def getUserCommunicationById(self, id):
1450 
    """
1451 
    Parameters:
1452 
     - id
1453 
    """
1454 
    self.send_getUserCommunicationById(id)
1455 
    return self.recv_getUserCommunicationById()
1456 
 
1457 
  def send_getUserCommunicationById(self, id):
1458 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1459 
    args = getUserCommunicationById_args()
1460 
    args.id = id
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_getUserCommunicationById(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = getUserCommunicationById_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
3431 rajveer 1475 
    if result.success is not None:
1590 varun.gupt 1476 
      return result.success
3431 rajveer 1477 
    if result.ucx is not None:
1590 varun.gupt 1478 
      raise result.ucx
1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1480 
 
1481 
  def getUserCommunicationByUser(self, userId):
1482 
    """
1483 
    Parameters:
1484 
     - userId
1485 
    """
1486 
    self.send_getUserCommunicationByUser(userId)
1487 
    return self.recv_getUserCommunicationByUser()
1488 
 
1489 
  def send_getUserCommunicationByUser(self, userId):
1490 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1491 
    args = getUserCommunicationByUser_args()
1492 
    args.userId = userId
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getUserCommunicationByUser(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getUserCommunicationByUser_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
1590 varun.gupt 1508 
      return result.success
3431 rajveer 1509 
    if result.ucx is not None:
1590 varun.gupt 1510 
      raise result.ucx
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1512 
 
1513 
  def getAllUserCommunications(self, ):
1514 
    self.send_getAllUserCommunications()
1515 
    return self.recv_getAllUserCommunications()
1516 
 
1517 
  def send_getAllUserCommunications(self, ):
1518 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1519 
    args = getAllUserCommunications_args()
1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
1524 
  def recv_getAllUserCommunications(self, ):
1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
1531 
    result = getAllUserCommunications_result()
1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
3431 rajveer 1534 
    if result.success is not None:
1590 varun.gupt 1535 
      return result.success
3431 rajveer 1536 
    if result.ucx is not None:
1590 varun.gupt 1537 
      raise result.ucx
1538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1539 
 
5407 amar.kumar 1540 
  def removeUserCommunication(self, id):
1541 
    """
1542 
    Parameters:
1543 
     - id
1544 
    """
1545 
    self.send_removeUserCommunication(id)
1546 
    self.recv_removeUserCommunication()
1547 
 
1548 
  def send_removeUserCommunication(self, id):
1549 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1550 
    args = removeUserCommunication_args()
1551 
    args.id = id
1552 
    args.write(self._oprot)
1553 
    self._oprot.writeMessageEnd()
1554 
    self._oprot.trans.flush()
1555 
 
1556 
  def recv_removeUserCommunication(self, ):
1557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1558 
    if mtype == TMessageType.EXCEPTION:
1559 
      x = TApplicationException()
1560 
      x.read(self._iprot)
1561 
      self._iprot.readMessageEnd()
1562 
      raise x
1563 
    result = removeUserCommunication_result()
1564 
    result.read(self._iprot)
1565 
    self._iprot.readMessageEnd()
1566 
    if result.ucx is not None:
1567 
      raise result.ucx
1568 
    return
1569 
 
1859 vikas 1570 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1571 
    """
1572 
    Parameters:
1573 
     - name
1859 vikas 1574 
     - addedOn
1845 vikas 1575 
    """
1859 vikas 1576 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1577 
    return self.recv_createMasterAffiliate()
1578 
 
1859 vikas 1579 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1580 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1581 
    args = createMasterAffiliate_args()
1582 
    args.name = name
1859 vikas 1583 
    args.addedOn = addedOn
1845 vikas 1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_createMasterAffiliate(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = createMasterAffiliate_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
3431 rajveer 1598 
    if result.success is not None:
1845 vikas 1599 
      return result.success
3431 rajveer 1600 
    if result.utx is not None:
1845 vikas 1601 
      raise result.utx
1602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1603 
 
1899 vikas 1604 
  def getAllMasterAffiliates(self, ):
1605 
    self.send_getAllMasterAffiliates()
1606 
    return self.recv_getAllMasterAffiliates()
1607 
 
1608 
  def send_getAllMasterAffiliates(self, ):
1609 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1610 
    args = getAllMasterAffiliates_args()
1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
1615 
  def recv_getAllMasterAffiliates(self, ):
1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
1622 
    result = getAllMasterAffiliates_result()
1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
3431 rajveer 1625 
    if result.success is not None:
1899 vikas 1626 
      return result.success
3431 rajveer 1627 
    if result.utx is not None:
1899 vikas 1628 
      raise result.utx
1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1630 
 
1845 vikas 1631 
  def getMasterAffiliateById(self, id):
1632 
    """
1633 
    Parameters:
1634 
     - id
1635 
    """
1636 
    self.send_getMasterAffiliateById(id)
1637 
    return self.recv_getMasterAffiliateById()
1638 
 
1639 
  def send_getMasterAffiliateById(self, id):
1640 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1641 
    args = getMasterAffiliateById_args()
1642 
    args.id = id
1643 
    args.write(self._oprot)
1644 
    self._oprot.writeMessageEnd()
1645 
    self._oprot.trans.flush()
1646 
 
1647 
  def recv_getMasterAffiliateById(self, ):
1648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1649 
    if mtype == TMessageType.EXCEPTION:
1650 
      x = TApplicationException()
1651 
      x.read(self._iprot)
1652 
      self._iprot.readMessageEnd()
1653 
      raise x
1654 
    result = getMasterAffiliateById_result()
1655 
    result.read(self._iprot)
1656 
    self._iprot.readMessageEnd()
3431 rajveer 1657 
    if result.success is not None:
1845 vikas 1658 
      return result.success
3431 rajveer 1659 
    if result.utx is not None:
1845 vikas 1660 
      raise result.utx
1661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1662 
 
1663 
  def getMasterAffiliateByName(self, name):
1664 
    """
1665 
    Parameters:
1666 
     - name
1667 
    """
1668 
    self.send_getMasterAffiliateByName(name)
1669 
    return self.recv_getMasterAffiliateByName()
1670 
 
1671 
  def send_getMasterAffiliateByName(self, name):
1672 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1673 
    args = getMasterAffiliateByName_args()
1674 
    args.name = name
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getMasterAffiliateByName(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getMasterAffiliateByName_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
3431 rajveer 1689 
    if result.success is not None:
1845 vikas 1690 
      return result.success
3431 rajveer 1691 
    if result.utx is not None:
1845 vikas 1692 
      raise result.utx
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1694 
 
1859 vikas 1695 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1696 
    """
1697 
    Parameters:
1698 
     - name
1699 
     - url
1700 
     - masterAffiliateId
1859 vikas 1701 
     - addedOn
1845 vikas 1702 
    """
1859 vikas 1703 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1704 
    return self.recv_createAffiliate()
1705 
 
1859 vikas 1706 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1707 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1708 
    args = createAffiliate_args()
1709 
    args.name = name
1710 
    args.url = url
1711 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1712 
    args.addedOn = addedOn
1845 vikas 1713 
    args.write(self._oprot)
1714 
    self._oprot.writeMessageEnd()
1715 
    self._oprot.trans.flush()
1716 
 
1717 
  def recv_createAffiliate(self, ):
1718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1719 
    if mtype == TMessageType.EXCEPTION:
1720 
      x = TApplicationException()
1721 
      x.read(self._iprot)
1722 
      self._iprot.readMessageEnd()
1723 
      raise x
1724 
    result = createAffiliate_result()
1725 
    result.read(self._iprot)
1726 
    self._iprot.readMessageEnd()
3431 rajveer 1727 
    if result.success is not None:
1845 vikas 1728 
      return result.success
3431 rajveer 1729 
    if result.utx is not None:
1845 vikas 1730 
      raise result.utx
1731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1732 
 
1733 
  def getAffiliateById(self, id):
1734 
    """
1735 
    Parameters:
1736 
     - id
1737 
    """
1738 
    self.send_getAffiliateById(id)
1739 
    return self.recv_getAffiliateById()
1740 
 
1741 
  def send_getAffiliateById(self, id):
1742 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1743 
    args = getAffiliateById_args()
1744 
    args.id = id
1745 
    args.write(self._oprot)
1746 
    self._oprot.writeMessageEnd()
1747 
    self._oprot.trans.flush()
1748 
 
1749 
  def recv_getAffiliateById(self, ):
1750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1751 
    if mtype == TMessageType.EXCEPTION:
1752 
      x = TApplicationException()
1753 
      x.read(self._iprot)
1754 
      self._iprot.readMessageEnd()
1755 
      raise x
1756 
    result = getAffiliateById_result()
1757 
    result.read(self._iprot)
1758 
    self._iprot.readMessageEnd()
3431 rajveer 1759 
    if result.success is not None:
1845 vikas 1760 
      return result.success
3431 rajveer 1761 
    if result.utx is not None:
1845 vikas 1762 
      raise result.utx
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1764 
 
1765 
  def getAffiliateByName(self, name):
1766 
    """
1767 
    Parameters:
1768 
     - name
1769 
    """
1770 
    self.send_getAffiliateByName(name)
1771 
    return self.recv_getAffiliateByName()
1772 
 
1773 
  def send_getAffiliateByName(self, name):
1774 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1775 
    args = getAffiliateByName_args()
1776 
    args.name = name
1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getAffiliateByName(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getAffiliateByName_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
3431 rajveer 1791 
    if result.success is not None:
1845 vikas 1792 
      return result.success
3431 rajveer 1793 
    if result.utx is not None:
1845 vikas 1794 
      raise result.utx
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1796 
 
1996 vikas 1797 
  def getTrackerById(self, id):
1845 vikas 1798 
    """
1799 
    Parameters:
1800 
     - id
1801 
    """
1996 vikas 1802 
    self.send_getTrackerById(id)
1845 vikas 1803 
    return self.recv_getTrackerById()
1804 
 
1996 vikas 1805 
  def send_getTrackerById(self, id):
1845 vikas 1806 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1807 
    args = getTrackerById_args()
1996 vikas 1808 
    args.id = id
1845 vikas 1809 
    args.write(self._oprot)
1810 
    self._oprot.writeMessageEnd()
1811 
    self._oprot.trans.flush()
1812 
 
1813 
  def recv_getTrackerById(self, ):
1814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1815 
    if mtype == TMessageType.EXCEPTION:
1816 
      x = TApplicationException()
1817 
      x.read(self._iprot)
1818 
      self._iprot.readMessageEnd()
1819 
      raise x
1820 
    result = getTrackerById_result()
1821 
    result.read(self._iprot)
1822 
    self._iprot.readMessageEnd()
3431 rajveer 1823 
    if result.success is not None:
1845 vikas 1824 
      return result.success
3431 rajveer 1825 
    if result.utx is not None:
1845 vikas 1826 
      raise result.utx
1827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1828 
 
1996 vikas 1829 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1830 
    """
1831 
    Parameters:
1996 vikas 1832 
     - id
1845 vikas 1833 
    """
1996 vikas 1834 
    self.send_getAffiliatesByMasterAffiliate(id)
1835 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1836 
 
1996 vikas 1837 
  def send_getAffiliatesByMasterAffiliate(self, id):
1838 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1839 
    args = getAffiliatesByMasterAffiliate_args()
1840 
    args.id = id
1845 vikas 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1996 vikas 1845 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1996 vikas 1852 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
1845 vikas 1856 
      return result.success
3431 rajveer 1857 
    if result.utx is not None:
1845 vikas 1858 
      raise result.utx
1996 vikas 1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1860 
 
1996 vikas 1861 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1862 
    """
1863 
    Parameters:
1996 vikas 1864 
     - affiliateId
1845 vikas 1865 
     - userId
1866 
     - event
1867 
     - url
1868 
     - data
1859 vikas 1869 
     - addedOn
1845 vikas 1870 
    """
1996 vikas 1871 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1872 
    return self.recv_addTrackLog()
1873 
 
1996 vikas 1874 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1875 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1876 
    args = addTrackLog_args()
1996 vikas 1877 
    args.affiliateId = affiliateId
1845 vikas 1878 
    args.userId = userId
1879 
    args.event = event
1880 
    args.url = url
1881 
    args.data = data
1859 vikas 1882 
    args.addedOn = addedOn
1845 vikas 1883 
    args.write(self._oprot)
1884 
    self._oprot.writeMessageEnd()
1885 
    self._oprot.trans.flush()
1886 
 
1887 
  def recv_addTrackLog(self, ):
1888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1889 
    if mtype == TMessageType.EXCEPTION:
1890 
      x = TApplicationException()
1891 
      x.read(self._iprot)
1892 
      self._iprot.readMessageEnd()
1893 
      raise x
1894 
    result = addTrackLog_result()
1895 
    result.read(self._iprot)
1896 
    self._iprot.readMessageEnd()
3431 rajveer 1897 
    if result.success is not None:
1845 vikas 1898 
      return result.success
3431 rajveer 1899 
    if result.utx is not None:
1845 vikas 1900 
      raise result.utx
1901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1902 
 
1903 
  def getTrackLogById(self, id):
1904 
    """
1905 
    Parameters:
1906 
     - id
1907 
    """
1908 
    self.send_getTrackLogById(id)
1909 
    return self.recv_getTrackLogById()
1910 
 
1911 
  def send_getTrackLogById(self, id):
1912 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1913 
    args = getTrackLogById_args()
1914 
    args.id = id
1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
1919 
  def recv_getTrackLogById(self, ):
1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
1926 
    result = getTrackLogById_result()
1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
3431 rajveer 1929 
    if result.success is not None:
1845 vikas 1930 
      return result.success
3431 rajveer 1931 
    if result.utx is not None:
1845 vikas 1932 
      raise result.utx
1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1934 
 
3293 vikas 1935 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1936 
    """
1937 
    Parameters:
1996 vikas 1938 
     - affiliateId
3293 vikas 1939 
     - startDate
1940 
     - endDate
1845 vikas 1941 
    """
3293 vikas 1942 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1943 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1944 
 
3293 vikas 1945 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1946 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1947 
    args = getTrackLogsByAffiliate_args()
1948 
    args.affiliateId = affiliateId
3293 vikas 1949 
    args.startDate = startDate
1950 
    args.endDate = endDate
1845 vikas 1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1996 vikas 1955 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1996 vikas 1962 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
3431 rajveer 1965 
    if result.success is not None:
1845 vikas 1966 
      return result.success
3431 rajveer 1967 
    if result.utx is not None:
1845 vikas 1968 
      raise result.utx
1996 vikas 1969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1970 
 
1971 
  def getTrackLogsByUser(self, userId):
1972 
    """
1973 
    Parameters:
1974 
     - userId
1975 
    """
1976 
    self.send_getTrackLogsByUser(userId)
1977 
    return self.recv_getTrackLogsByUser()
1978 
 
1979 
  def send_getTrackLogsByUser(self, userId):
1980 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1981 
    args = getTrackLogsByUser_args()
1982 
    args.userId = userId
1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1987 
  def recv_getTrackLogsByUser(self, ):
1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1994 
    result = getTrackLogsByUser_result()
1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
1845 vikas 1998 
      return result.success
3431 rajveer 1999 
    if result.utx is not None:
1845 vikas 2000 
      raise result.utx
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2002 
 
1996 vikas 2003 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2004 
    """
2005 
    Parameters:
2006 
     - userId
2007 
     - event
2008 
     - url
2009 
    """
1996 vikas 2010 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2011 
    return self.recv_getTrackLogs()
2012 
 
1996 vikas 2013 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2014 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2015 
    args = getTrackLogs_args()
2016 
    args.userId = userId
2017 
    args.event = event
2018 
    args.url = url
2019 
    args.write(self._oprot)
2020 
    self._oprot.writeMessageEnd()
2021 
    self._oprot.trans.flush()
2022 
 
2023 
  def recv_getTrackLogs(self, ):
2024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2025 
    if mtype == TMessageType.EXCEPTION:
2026 
      x = TApplicationException()
2027 
      x.read(self._iprot)
2028 
      self._iprot.readMessageEnd()
2029 
      raise x
2030 
    result = getTrackLogs_result()
2031 
    result.read(self._iprot)
2032 
    self._iprot.readMessageEnd()
3431 rajveer 2033 
    if result.success is not None:
1845 vikas 2034 
      return result.success
3431 rajveer 2035 
    if result.utx is not None:
1845 vikas 2036 
      raise result.utx
2037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2038 
 
559 chandransh 2039 
  def getCurrentCart(self, userId):
94 ashish 2040 
    """
2041 
    Parameters:
559 chandransh 2042 
     - userId
94 ashish 2043 
    """
559 chandransh 2044 
    self.send_getCurrentCart(userId)
2045 
    return self.recv_getCurrentCart()
94 ashish 2046 
 
559 chandransh 2047 
  def send_getCurrentCart(self, userId):
2048 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2049 
    args = getCurrentCart_args()
2050 
    args.userId = userId
94 ashish 2051 
    args.write(self._oprot)
2052 
    self._oprot.writeMessageEnd()
2053 
    self._oprot.trans.flush()
2054 
 
559 chandransh 2055 
  def recv_getCurrentCart(self, ):
94 ashish 2056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2057 
    if mtype == TMessageType.EXCEPTION:
2058 
      x = TApplicationException()
2059 
      x.read(self._iprot)
2060 
      self._iprot.readMessageEnd()
2061 
      raise x
559 chandransh 2062 
    result = getCurrentCart_result()
94 ashish 2063 
    result.read(self._iprot)
2064 
    self._iprot.readMessageEnd()
3431 rajveer 2065 
    if result.success is not None:
94 ashish 2066 
      return result.success
3431 rajveer 2067 
    if result.scx is not None:
559 chandransh 2068 
      raise result.scx
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2070 
 
559 chandransh 2071 
  def getCart(self, cartId):
94 ashish 2072 
    """
2073 
    Parameters:
559 chandransh 2074 
     - cartId
94 ashish 2075 
    """
559 chandransh 2076 
    self.send_getCart(cartId)
2077 
    return self.recv_getCart()
94 ashish 2078 
 
559 chandransh 2079 
  def send_getCart(self, cartId):
2080 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2081 
    args = getCart_args()
2082 
    args.cartId = cartId
94 ashish 2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
559 chandransh 2087 
  def recv_getCart(self, ):
94 ashish 2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
559 chandransh 2094 
    result = getCart_result()
94 ashish 2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
3431 rajveer 2097 
    if result.success is not None:
94 ashish 2098 
      return result.success
3431 rajveer 2099 
    if result.scx is not None:
559 chandransh 2100 
      raise result.scx
2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2102 
 
559 chandransh 2103 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2104 
    """
2105 
    Parameters:
559 chandransh 2106 
     - from_time
2107 
     - to_time
2108 
     - status
94 ashish 2109 
    """
559 chandransh 2110 
    self.send_getCartsByTime(from_time, to_time, status)
2111 
    return self.recv_getCartsByTime()
94 ashish 2112 
 
559 chandransh 2113 
  def send_getCartsByTime(self, from_time, to_time, status):
2114 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2115 
    args = getCartsByTime_args()
2116 
    args.from_time = from_time
2117 
    args.to_time = to_time
2118 
    args.status = status
94 ashish 2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
559 chandransh 2123 
  def recv_getCartsByTime(self, ):
94 ashish 2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
559 chandransh 2130 
    result = getCartsByTime_result()
94 ashish 2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
3431 rajveer 2133 
    if result.success is not None:
94 ashish 2134 
      return result.success
3431 rajveer 2135 
    if result.scx is not None:
559 chandransh 2136 
      raise result.scx
2137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2138 
 
3557 rajveer 2139 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2140 
    """
2141 
    Parameters:
2142 
     - cartId
2143 
     - itemId
2144 
     - quantity
3557 rajveer 2145 
     - sourceId
559 chandransh 2146 
    """
3557 rajveer 2147 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2148 
    return self.recv_addItemToCart()
559 chandransh 2149 
 
3557 rajveer 2150 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2151 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2152 
    args = addItemToCart_args()
2153 
    args.cartId = cartId
2154 
    args.itemId = itemId
2155 
    args.quantity = quantity
3557 rajveer 2156 
    args.sourceId = sourceId
559 chandransh 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()
3431 rajveer 2171 
    if result.success is not None:
2035 rajveer 2172 
      return result.success
3431 rajveer 2173 
    if result.scx is not None:
559 chandransh 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()
3431 rajveer 2205 
    if result.scx is not None:
559 chandransh 2206 
      raise result.scx
2207 
    return
2208 
 
2209 
  def addAddressToCart(self, cartId, addressId):
2210 
    """
2211 
    Parameters:
2212 
     - cartId
2213 
     - addressId
2214 
    """
2215 
    self.send_addAddressToCart(cartId, addressId)
2216 
    self.recv_addAddressToCart()
2217 
 
2218 
  def send_addAddressToCart(self, cartId, addressId):
2219 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2220 
    args = addAddressToCart_args()
2221 
    args.cartId = cartId
2222 
    args.addressId = addressId
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_addAddressToCart(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = addAddressToCart_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.scx is not None:
575 chandransh 2238 
      raise result.scx
559 chandransh 2239 
    return
2240 
 
5553 rajveer 2241 
  def addStoreToCart(self, cartId, storeId):
2242 
    """
2243 
    Parameters:
2244 
     - cartId
2245 
     - storeId
2246 
    """
2247 
    self.send_addStoreToCart(cartId, storeId)
2248 
    self.recv_addStoreToCart()
2249 
 
2250 
  def send_addStoreToCart(self, cartId, storeId):
2251 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2252 
    args = addStoreToCart_args()
2253 
    args.cartId = cartId
2254 
    args.storeId = storeId
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_addStoreToCart(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = addStoreToCart_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    if result.scx is not None:
2270 
      raise result.scx
2271 
    return
2272 
 
6922 anupam.sin 2273 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2274 
    """
2275 
    Parameters:
6922 anupam.sin 2276 
     - cart
1976 varun.gupt 2277 
     - couponCode
2278 
    """
6922 anupam.sin 2279 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2280 
    self.recv_applyCouponToCart()
2281 
 
6922 anupam.sin 2282 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2283 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2284 
    args = applyCouponToCart_args()
6922 anupam.sin 2285 
    args.cart = cart
1976 varun.gupt 2286 
    args.couponCode = couponCode
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_applyCouponToCart(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = applyCouponToCart_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
3431 rajveer 2301 
    if result.scx is not None:
1976 varun.gupt 2302 
      raise result.scx
2303 
    return
2304 
 
2305 
  def removeCoupon(self, cartId):
2306 
    """
2307 
    Parameters:
2308 
     - cartId
2309 
    """
2310 
    self.send_removeCoupon(cartId)
2311 
    self.recv_removeCoupon()
2312 
 
2313 
  def send_removeCoupon(self, cartId):
2314 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2315 
    args = removeCoupon_args()
2316 
    args.cartId = cartId
2317 
    args.write(self._oprot)
2318 
    self._oprot.writeMessageEnd()
2319 
    self._oprot.trans.flush()
2320 
 
2321 
  def recv_removeCoupon(self, ):
2322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2323 
    if mtype == TMessageType.EXCEPTION:
2324 
      x = TApplicationException()
2325 
      x.read(self._iprot)
2326 
      self._iprot.readMessageEnd()
2327 
      raise x
2328 
    result = removeCoupon_result()
2329 
    result.read(self._iprot)
2330 
    self._iprot.readMessageEnd()
3431 rajveer 2331 
    if result.scx is not None:
1976 varun.gupt 2332 
      raise result.scx
2333 
    return
2334 
 
3554 varun.gupt 2335 
  def deleteDiscountsFromCart(self, cartId):
2336 
    """
2337 
    Deletes all the discounts associated with the cart
2338 
 
2339 
    Parameters:
2340 
     - cartId
2341 
    """
2342 
    self.send_deleteDiscountsFromCart(cartId)
2343 
    self.recv_deleteDiscountsFromCart()
2344 
 
2345 
  def send_deleteDiscountsFromCart(self, cartId):
2346 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2347 
    args = deleteDiscountsFromCart_args()
2348 
    args.cartId = cartId
2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
2353 
  def recv_deleteDiscountsFromCart(self, ):
2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
2360 
    result = deleteDiscountsFromCart_result()
2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
2363 
    if result.scx is not None:
2364 
      raise result.scx
2365 
    return
2366 
 
2367 
  def saveDiscounts(self, discounts):
2368 
    """
2369 
    Accepts a list of thrift objects of Discount type and saves them
2370 
 
2371 
    Parameters:
2372 
     - discounts
2373 
    """
2374 
    self.send_saveDiscounts(discounts)
2375 
    self.recv_saveDiscounts()
2376 
 
2377 
  def send_saveDiscounts(self, discounts):
2378 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2379 
    args = saveDiscounts_args()
2380 
    args.discounts = discounts
2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
2385 
  def recv_saveDiscounts(self, ):
2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
2392 
    result = saveDiscounts_result()
2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
2395 
    if result.scx is not None:
2396 
      raise result.scx
2397 
    return
2398 
 
11526 amit.gupta 2399 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2400 
    """
690 chandransh 2401 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2402 
 
559 chandransh 2403 
    Parameters:
2404 
     - cartId
2815 vikas 2405 
     - sessionSource
2406 
     - sessionStartTime
3858 vikas 2407 
     - firstSource
2408 
     - firstSourceTime
5326 rajveer 2409 
     - userId
6389 rajveer 2410 
     - schemeId
11526 amit.gupta 2411 
     - orderSource
559 chandransh 2412 
    """
11526 amit.gupta 2413 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2414 
    return self.recv_createOrders()
559 chandransh 2415 
 
11526 amit.gupta 2416 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2417 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2418 
    args = createOrders_args()
559 chandransh 2419 
    args.cartId = cartId
2815 vikas 2420 
    args.sessionSource = sessionSource
2421 
    args.sessionStartTime = sessionStartTime
3858 vikas 2422 
    args.firstSource = firstSource
2423 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2424 
    args.userId = userId
6389 rajveer 2425 
    args.schemeId = schemeId
11526 amit.gupta 2426 
    args.orderSource = orderSource
559 chandransh 2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
690 chandransh 2431 
  def recv_createOrders(self, ):
559 chandransh 2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
690 chandransh 2438 
    result = createOrders_result()
559 chandransh 2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
3431 rajveer 2441 
    if result.success is not None:
130 ashish 2442 
      return result.success
3431 rajveer 2443 
    if result.scx is not None:
559 chandransh 2444 
      raise result.scx
690 chandransh 2445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2446 
 
3557 rajveer 2447 
  def validateCart(self, cartId, sourceId):
130 ashish 2448 
    """
690 chandransh 2449 
    Validates that:
2450 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2451 
    2. All of the lines in the cart are active items.
690 chandransh 2452 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2453 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2454 
 
130 ashish 2455 
    Parameters:
559 chandransh 2456 
     - cartId
3557 rajveer 2457 
     - sourceId
130 ashish 2458 
    """
3557 rajveer 2459 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2460 
    return self.recv_validateCart()
130 ashish 2461 
 
3557 rajveer 2462 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2463 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2464 
    args = validateCart_args()
2465 
    args.cartId = cartId
3557 rajveer 2466 
    args.sourceId = sourceId
130 ashish 2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
559 chandransh 2471 
  def recv_validateCart(self, ):
130 ashish 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
559 chandransh 2478 
    result = validateCart_result()
130 ashish 2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
3431 rajveer 2481 
    if result.success is not None:
130 ashish 2482 
      return result.success
3431 rajveer 2483 
    if result.scex is not None:
575 chandransh 2484 
      raise result.scex
559 chandransh 2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2486 
 
11980 amit.gupta 2487 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2488 
    """
2489 
    Validates that:
2490 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2491 
    2. All of the lines in the cart are active items.
2492 
    3. The estimate for any of the lines in cart doesn't change.
2493 
    If all three are true, returns empty string; else returns appropriate message.
2494 
 
2495 
    Parameters:
2496 
     - cartId
2497 
     - sourceId
2498 
     - dealCoupon
2499 
    """
2500 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2501 
    return self.recv_validateCartWithDealerCoupon()
2502 
 
2503 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2504 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2505 
    args = validateCartWithDealerCoupon_args()
2506 
    args.cartId = cartId
2507 
    args.sourceId = sourceId
2508 
    args.dealCoupon = dealCoupon
2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_validateCartWithDealerCoupon(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = validateCartWithDealerCoupon_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
2523 
    if result.success is not None:
2524 
      return result.success
2525 
    if result.scex is not None:
2526 
      raise result.scex
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2528 
 
690 chandransh 2529 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2530 
    """
690 chandransh 2531 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2532 
 
575 chandransh 2533 
    Parameters:
690 chandransh 2534 
     - fromCartId
2535 
     - toCartId
2536 
    """
2537 
    self.send_mergeCart(fromCartId, toCartId)
2538 
    self.recv_mergeCart()
2539 
 
2540 
  def send_mergeCart(self, fromCartId, toCartId):
2541 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2542 
    args = mergeCart_args()
2543 
    args.fromCartId = fromCartId
2544 
    args.toCartId = toCartId
2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
2549 
  def recv_mergeCart(self, ):
2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
2556 
    result = mergeCart_result()
2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
2559 
    return
2560 
 
2561 
  def checkOut(self, cartId):
2562 
    """
2563 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2564 
 
690 chandransh 2565 
    Parameters:
575 chandransh 2566 
     - cartId
2567 
    """
690 chandransh 2568 
    self.send_checkOut(cartId)
2569 
    return self.recv_checkOut()
575 chandransh 2570 
 
690 chandransh 2571 
  def send_checkOut(self, cartId):
2572 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2573 
    args = checkOut_args()
575 chandransh 2574 
    args.cartId = cartId
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
690 chandransh 2579 
  def recv_checkOut(self, ):
575 chandransh 2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
690 chandransh 2586 
    result = checkOut_result()
575 chandransh 2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
3431 rajveer 2589 
    if result.success is not None:
575 chandransh 2590 
      return result.success
3431 rajveer 2591 
    if result.scex is not None:
575 chandransh 2592 
      raise result.scex
690 chandransh 2593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2594 
 
690 chandransh 2595 
  def resetCart(self, cartId, items):
559 chandransh 2596 
    """
690 chandransh 2597 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2598 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2599 
 
559 chandransh 2600 
    Parameters:
690 chandransh 2601 
     - cartId
2602 
     - items
559 chandransh 2603 
    """
690 chandransh 2604 
    self.send_resetCart(cartId, items)
2605 
    return self.recv_resetCart()
130 ashish 2606 
 
690 chandransh 2607 
  def send_resetCart(self, cartId, items):
2608 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2609 
    args = resetCart_args()
2610 
    args.cartId = cartId
2611 
    args.items = items
559 chandransh 2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
690 chandransh 2616 
  def recv_resetCart(self, ):
559 chandransh 2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
690 chandransh 2623 
    result = resetCart_result()
559 chandransh 2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
3431 rajveer 2626 
    if result.success is not None:
690 chandransh 2627 
      return result.success
3431 rajveer 2628 
    if result.scex is not None:
690 chandransh 2629 
      raise result.scex
2630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2631 
 
2981 rajveer 2632 
  def getUserCount(self, userType):
559 chandransh 2633 
    """
2981 rajveer 2634 
    Returns number of registered users.
2635 
    If userType = null, then it returns count of all users, including anonymous
2636 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2637 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2638 
 
559 chandransh 2639 
    Parameters:
2981 rajveer 2640 
     - userType
559 chandransh 2641 
    """
2981 rajveer 2642 
    self.send_getUserCount(userType)
2643 
    return self.recv_getUserCount()
559 chandransh 2644 
 
2981 rajveer 2645 
  def send_getUserCount(self, userType):
2646 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2647 
    args = getUserCount_args()
2648 
    args.userType = userType
559 chandransh 2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
2981 rajveer 2653 
  def recv_getUserCount(self, ):
559 chandransh 2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
2981 rajveer 2660 
    result = getUserCount_result()
559 chandransh 2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
3431 rajveer 2663 
    if result.success is not None:
559 chandransh 2664 
      return result.success
2981 rajveer 2665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2666 
 
2981 rajveer 2667 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2668 
    """
2981 rajveer 2669 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2670 
    If any of startDate or endDate is -1, then that filter is ignored.
2671 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2672 
 
2673 
 
559 chandransh 2674 
    Parameters:
2981 rajveer 2675 
     - userType
2676 
     - startDate
2677 
     - endDate
559 chandransh 2678 
    """
2981 rajveer 2679 
    self.send_getAllUsers(userType, startDate, endDate)
2680 
    return self.recv_getAllUsers()
559 chandransh 2681 
 
2981 rajveer 2682 
  def send_getAllUsers(self, userType, startDate, endDate):
2683 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2684 
    args = getAllUsers_args()
2685 
    args.userType = userType
2686 
    args.startDate = startDate
2687 
    args.endDate = endDate
559 chandransh 2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2981 rajveer 2692 
  def recv_getAllUsers(self, ):
559 chandransh 2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2981 rajveer 2699 
    result = getAllUsers_result()
559 chandransh 2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
3431 rajveer 2702 
    if result.success is not None:
559 chandransh 2703 
      return result.success
2981 rajveer 2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2705 
 
2981 rajveer 2706 
  def getMyResearchItems(self, userId):
559 chandransh 2707 
    """
2981 rajveer 2708 
    Returns list of item ids in myresearch for the user
3431 rajveer 2709 
 
559 chandransh 2710 
    Parameters:
772 rajveer 2711 
     - userId
559 chandransh 2712 
    """
2981 rajveer 2713 
    self.send_getMyResearchItems(userId)
2714 
    return self.recv_getMyResearchItems()
559 chandransh 2715 
 
2981 rajveer 2716 
  def send_getMyResearchItems(self, userId):
2717 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2718 
    args = getMyResearchItems_args()
772 rajveer 2719 
    args.userId = userId
559 chandransh 2720 
    args.write(self._oprot)
2721 
    self._oprot.writeMessageEnd()
2722 
    self._oprot.trans.flush()
2723 
 
2981 rajveer 2724 
  def recv_getMyResearchItems(self, ):
559 chandransh 2725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2726 
    if mtype == TMessageType.EXCEPTION:
2727 
      x = TApplicationException()
2728 
      x.read(self._iprot)
2729 
      self._iprot.readMessageEnd()
2730 
      raise x
2981 rajveer 2731 
    result = getMyResearchItems_result()
559 chandransh 2732 
    result.read(self._iprot)
2733 
    self._iprot.readMessageEnd()
3431 rajveer 2734 
    if result.success is not None:
559 chandransh 2735 
      return result.success
3431 rajveer 2736 
    if result.scx is not None:
559 chandransh 2737 
      raise result.scx
2981 rajveer 2738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2739 
 
2981 rajveer 2740 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2741 
    """
2981 rajveer 2742 
    add item to my research for a user
3431 rajveer 2743 
 
559 chandransh 2744 
    Parameters:
2981 rajveer 2745 
     - userId
2746 
     - itemId
559 chandransh 2747 
    """
2981 rajveer 2748 
    self.send_updateMyResearch(userId, itemId)
2749 
    return self.recv_updateMyResearch()
559 chandransh 2750 
 
2981 rajveer 2751 
  def send_updateMyResearch(self, userId, itemId):
2752 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2753 
    args = updateMyResearch_args()
2754 
    args.userId = userId
2755 
    args.itemId = itemId
559 chandransh 2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2981 rajveer 2760 
  def recv_updateMyResearch(self, ):
559 chandransh 2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2981 rajveer 2767 
    result = updateMyResearch_result()
559 chandransh 2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
3431 rajveer 2770 
    if result.success is not None:
2981 rajveer 2771 
      return result.success
3431 rajveer 2772 
    if result.scx is not None:
2981 rajveer 2773 
      raise result.scx
2774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2775 
 
2981 rajveer 2776 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2777 
    """
2981 rajveer 2778 
    delete item from my research for a user
3431 rajveer 2779 
 
1596 ankur.sing 2780 
    Parameters:
2981 rajveer 2781 
     - userId
2782 
     - itemId
1596 ankur.sing 2783 
    """
2981 rajveer 2784 
    self.send_deleteItemFromMyResearch(userId, itemId)
2785 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2786 
 
2981 rajveer 2787 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2788 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2789 
    args = deleteItemFromMyResearch_args()
2790 
    args.userId = userId
2791 
    args.itemId = itemId
1596 ankur.sing 2792 
    args.write(self._oprot)
2793 
    self._oprot.writeMessageEnd()
2794 
    self._oprot.trans.flush()
2795 
 
2981 rajveer 2796 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2798 
    if mtype == TMessageType.EXCEPTION:
2799 
      x = TApplicationException()
2800 
      x.read(self._iprot)
2801 
      self._iprot.readMessageEnd()
2802 
      raise x
2981 rajveer 2803 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2804 
    result.read(self._iprot)
2805 
    self._iprot.readMessageEnd()
3431 rajveer 2806 
    if result.scx is not None:
2981 rajveer 2807 
      raise result.scx
2808 
    return
1596 ankur.sing 2809 
 
2981 rajveer 2810 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2811 
    """
2981 rajveer 2812 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2813 
 
1673 ankur.sing 2814 
    Parameters:
2981 rajveer 2815 
     - userId
1673 ankur.sing 2816 
    """
2981 rajveer 2817 
    self.send_getBrowseHistoryItems(userId)
2818 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2819 
 
2981 rajveer 2820 
  def send_getBrowseHistoryItems(self, userId):
2821 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2822 
    args = getBrowseHistoryItems_args()
2823 
    args.userId = userId
1673 ankur.sing 2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2981 rajveer 2828 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2981 rajveer 2835 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
3431 rajveer 2838 
    if result.success is not None:
1673 ankur.sing 2839 
      return result.success
3431 rajveer 2840 
    if result.scx is not None:
2981 rajveer 2841 
      raise result.scx
2842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2843 
 
2981 rajveer 2844 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2845 
    """
2981 rajveer 2846 
    add item to browse history for a user
3431 rajveer 2847 
 
2642 varun.gupt 2848 
    Parameters:
2981 rajveer 2849 
     - userId
2850 
     - itemId
2642 varun.gupt 2851 
    """
2981 rajveer 2852 
    self.send_updateBrowseHistory(userId, itemId)
2853 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2854 
 
2981 rajveer 2855 
  def send_updateBrowseHistory(self, userId, itemId):
2856 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2857 
    args = updateBrowseHistory_args()
2858 
    args.userId = userId
2859 
    args.itemId = itemId
2642 varun.gupt 2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2981 rajveer 2864 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2981 rajveer 2871 
    result = updateBrowseHistory_result()
2642 varun.gupt 2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
2874 
    return
2875 
 
3385 varun.gupt 2876 
  def getCartsWithCouponCount(self, couponCode):
2877 
    """
2878 
    Returns count of Carts with given coupon applied
3431 rajveer 2879 
 
3385 varun.gupt 2880 
    Parameters:
2881 
     - couponCode
2882 
    """
2883 
    self.send_getCartsWithCouponCount(couponCode)
2884 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2885 
 
3385 varun.gupt 2886 
  def send_getCartsWithCouponCount(self, couponCode):
2887 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2888 
    args = getCartsWithCouponCount_args()
2889 
    args.couponCode = couponCode
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_getCartsWithCouponCount(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = getCartsWithCouponCount_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
3431 rajveer 2904 
    if result.success is not None:
3385 varun.gupt 2905 
      return result.success
2906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2907 
 
3499 mandeep.dh 2908 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2909 
    """
2910 
    Updates COD trust level of a user
3385 varun.gupt 2911 
 
3499 mandeep.dh 2912 
    Parameters:
2913 
     - userId
2914 
     - trustLevelDelta
2915 
    """
2916 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2917 
 
2918 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2919 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2920 
    args = increaseTrustLevel_args()
2921 
    args.userId = userId
2922 
    args.trustLevelDelta = trustLevelDelta
2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
5407 amar.kumar 2926 
  def getTrustLevel(self, userId):
2927 
    """
2928 
    Get trust level of a user
2929 
 
2930 
    Parameters:
2931 
     - userId
2932 
    """
2933 
    self.send_getTrustLevel(userId)
2934 
    return self.recv_getTrustLevel()
2935 
 
2936 
  def send_getTrustLevel(self, userId):
2937 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2938 
    args = getTrustLevel_args()
2939 
    args.userId = userId
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_getTrustLevel(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = getTrustLevel_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2957 
 
4668 varun.gupt 2958 
  def showCODOption(self, cartId, sourceId, pincode):
2959 
    """
2960 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2961 
 
4668 varun.gupt 2962 
    Parameters:
2963 
     - cartId
2964 
     - sourceId
2965 
     - pincode
2966 
    """
2967 
    self.send_showCODOption(cartId, sourceId, pincode)
2968 
    return self.recv_showCODOption()
2969 
 
2970 
  def send_showCODOption(self, cartId, sourceId, pincode):
2971 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2972 
    args = showCODOption_args()
2973 
    args.cartId = cartId
2974 
    args.sourceId = sourceId
2975 
    args.pincode = pincode
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_showCODOption(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = showCODOption_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
2993 
 
5623 anupam.sin 2994 
  def getUserEmails(self, startDate, endDate):
2995 
    """
2996 
    Get email addresses for users activated within a given date range
4668 varun.gupt 2997 
 
5623 anupam.sin 2998 
    Parameters:
2999 
     - startDate
3000 
     - endDate
3001 
    """
3002 
    self.send_getUserEmails(startDate, endDate)
3003 
    return self.recv_getUserEmails()
3004 
 
3005 
  def send_getUserEmails(self, startDate, endDate):
3006 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3007 
    args = getUserEmails_args()
3008 
    args.startDate = startDate
3009 
    args.endDate = endDate
3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_getUserEmails(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = getUserEmails_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    if result.success is not None:
3025 
      return result.success
3026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3027 
 
9299 kshitij.so 3028 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3029 
    """
3030 
    Mark a cart lineitem as insured. Returns true/false.
3031 
 
3032 
    Parameters:
3033 
     - itemId
3034 
     - cartId
3035 
     - toInsure
9299 kshitij.so 3036 
     - insurerType
6903 anupam.sin 3037 
    """
9299 kshitij.so 3038 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3039 
    return self.recv_insureItem()
3040 
 
9299 kshitij.so 3041 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3042 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3043 
    args = insureItem_args()
3044 
    args.itemId = itemId
3045 
    args.cartId = cartId
3046 
    args.toInsure = toInsure
9299 kshitij.so 3047 
    args.insurerType = insurerType
6903 anupam.sin 3048 
    args.write(self._oprot)
3049 
    self._oprot.writeMessageEnd()
3050 
    self._oprot.trans.flush()
3051 
 
3052 
  def recv_insureItem(self, ):
3053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3054 
    if mtype == TMessageType.EXCEPTION:
3055 
      x = TApplicationException()
3056 
      x.read(self._iprot)
3057 
      self._iprot.readMessageEnd()
3058 
      raise x
3059 
    result = insureItem_result()
3060 
    result.read(self._iprot)
3061 
    self._iprot.readMessageEnd()
3062 
    if result.success is not None:
3063 
      return result.success
3064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3065 
 
3066 
  def cancelInsurance(self, cartId):
3067 
    """
3068 
    Cancel insurance for all items in the cart
3069 
 
3070 
    Parameters:
3071 
     - cartId
3072 
    """
3073 
    self.send_cancelInsurance(cartId)
3074 
    return self.recv_cancelInsurance()
3075 
 
3076 
  def send_cancelInsurance(self, cartId):
3077 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3078 
    args = cancelInsurance_args()
3079 
    args.cartId = cartId
3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
3084 
  def recv_cancelInsurance(self, ):
3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
3091 
    result = cancelInsurance_result()
3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3094 
    if result.success is not None:
3095 
      return result.success
3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3097 
 
3098 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3099 
    """
3100 
    Stores insurance specific details like date of birth and guardianName
3101 
 
3102 
    Parameters:
3103 
     - addressId
3104 
     - dob
3105 
     - guardianName
3106 
    """
3107 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3108 
    return self.recv_storeInsuranceSpecificDetails()
3109 
 
3110 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3111 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3112 
    args = storeInsuranceSpecificDetails_args()
3113 
    args.addressId = addressId
3114 
    args.dob = dob
3115 
    args.guardianName = guardianName
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_storeInsuranceSpecificDetails(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = storeInsuranceSpecificDetails_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3130 
    if result.success is not None:
3131 
      return result.success
3132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3133 
 
3134 
  def isInsuranceDetailPresent(self, addressId):
3135 
    """
3136 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3137 
 
3138 
    Parameters:
3139 
     - addressId
3140 
    """
3141 
    self.send_isInsuranceDetailPresent(addressId)
3142 
    return self.recv_isInsuranceDetailPresent()
3143 
 
3144 
  def send_isInsuranceDetailPresent(self, addressId):
3145 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3146 
    args = isInsuranceDetailPresent_args()
3147 
    args.addressId = addressId
3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_isInsuranceDetailPresent(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = isInsuranceDetailPresent_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3162 
    if result.success is not None:
3163 
      return result.success
3164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3165 
 
9791 rajveer 3166 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3167 
    """
9791 rajveer 3168 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3169 
 
6821 amar.kumar 3170 
    Parameters:
3171 
     - startDate
3172 
     - endDate
3173 
    """
9791 rajveer 3174 
    self.send_getProductsAddedToCart(startDate, endDate)
3175 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3176 
 
9791 rajveer 3177 
  def send_getProductsAddedToCart(self, startDate, endDate):
3178 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3179 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3180 
    args.startDate = startDate
3181 
    args.endDate = endDate
3182 
    args.write(self._oprot)
3183 
    self._oprot.writeMessageEnd()
3184 
    self._oprot.trans.flush()
3185 
 
9791 rajveer 3186 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3188 
    if mtype == TMessageType.EXCEPTION:
3189 
      x = TApplicationException()
3190 
      x.read(self._iprot)
3191 
      self._iprot.readMessageEnd()
3192 
      raise x
9791 rajveer 3193 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3194 
    result.read(self._iprot)
3195 
    self._iprot.readMessageEnd()
3196 
    if result.success is not None:
3197 
      return result.success
9791 rajveer 3198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3199 
 
11980 amit.gupta 3200 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3201 
    """
3202 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3203 
 
11592 amit.gupta 3204 
    Parameters:
3205 
     - cartId
3206 
     - sourceId
11980 amit.gupta 3207 
     - dealerCoupon
11592 amit.gupta 3208 
    """
11980 amit.gupta 3209 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3210 
    return self.recv_validateCartPlus()
3211 
 
11980 amit.gupta 3212 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3213 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3214 
    args = validateCartPlus_args()
3215 
    args.cartId = cartId
3216 
    args.sourceId = sourceId
11980 amit.gupta 3217 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3218 
    args.write(self._oprot)
3219 
    self._oprot.writeMessageEnd()
3220 
    self._oprot.trans.flush()
3221 
 
3222 
  def recv_validateCartPlus(self, ):
3223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3224 
    if mtype == TMessageType.EXCEPTION:
3225 
      x = TApplicationException()
3226 
      x.read(self._iprot)
3227 
      self._iprot.readMessageEnd()
3228 
      raise x
3229 
    result = validateCartPlus_result()
3230 
    result.read(self._iprot)
3231 
    self._iprot.readMessageEnd()
3232 
    if result.success is not None:
3233 
      return result.success
3234 
    if result.scex is not None:
3235 
      raise result.scex
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3237 
 
11679 vikram.rag 3238 
  def isPrivateDealUser(self, userId):
3239 
    """
3240 
    Parameters:
3241 
     - userId
3242 
    """
3243 
    self.send_isPrivateDealUser(userId)
3244 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3245 
 
11679 vikram.rag 3246 
  def send_isPrivateDealUser(self, userId):
3247 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3248 
    args = isPrivateDealUser_args()
3249 
    args.userId = userId
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_isPrivateDealUser(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = isPrivateDealUser_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
3266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3267 
 
11890 kshitij.so 3268 
  def addPrivateDealUser(self, userId):
3269 
    """
3270 
    Parameters:
3271 
     - userId
3272 
    """
3273 
    self.send_addPrivateDealUser(userId)
3274 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3275 
 
11890 kshitij.so 3276 
  def send_addPrivateDealUser(self, userId):
3277 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3278 
    args = addPrivateDealUser_args()
3279 
    args.userId = userId
3280 
    args.write(self._oprot)
3281 
    self._oprot.writeMessageEnd()
3282 
    self._oprot.trans.flush()
3283 
 
3284 
  def recv_addPrivateDealUser(self, ):
3285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3286 
    if mtype == TMessageType.EXCEPTION:
3287 
      x = TApplicationException()
3288 
      x.read(self._iprot)
3289 
      self._iprot.readMessageEnd()
3290 
      raise x
3291 
    result = addPrivateDealUser_result()
3292 
    result.read(self._iprot)
3293 
    self._iprot.readMessageEnd()
3294 
    if result.success is not None:
3295 
      return result.success
3296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3297 
 
3298 
  def changePrivateDealUserStatus(self, userId, isActive):
3299 
    """
3300 
    Parameters:
3301 
     - userId
3302 
     - isActive
3303 
    """
3304 
    self.send_changePrivateDealUserStatus(userId, isActive)
3305 
    return self.recv_changePrivateDealUserStatus()
3306 
 
3307 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3308 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3309 
    args = changePrivateDealUserStatus_args()
3310 
    args.userId = userId
3311 
    args.isActive = isActive
3312 
    args.write(self._oprot)
3313 
    self._oprot.writeMessageEnd()
3314 
    self._oprot.trans.flush()
3315 
 
3316 
  def recv_changePrivateDealUserStatus(self, ):
3317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3318 
    if mtype == TMessageType.EXCEPTION:
3319 
      x = TApplicationException()
3320 
      x.read(self._iprot)
3321 
      self._iprot.readMessageEnd()
3322 
      raise x
3323 
    result = changePrivateDealUserStatus_result()
3324 
    result.read(self._iprot)
3325 
    self._iprot.readMessageEnd()
3326 
    if result.success is not None:
3327 
      return result.success
3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3329 
 
3330 
  def getPrivateDealUser(self, userId):
3331 
    """
3332 
    Parameters:
3333 
     - userId
3334 
    """
3335 
    self.send_getPrivateDealUser(userId)
3336 
    return self.recv_getPrivateDealUser()
3337 
 
3338 
  def send_getPrivateDealUser(self, userId):
3339 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3340 
    args = getPrivateDealUser_args()
3341 
    args.userId = userId
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_getPrivateDealUser(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = getPrivateDealUser_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.success is not None:
3357 
      return result.success
3358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3359 
 
12696 amit.gupta 3360 
  def registerCounter(self, counter, userId):
3361 
    """
3362 
    Parameters:
3363 
     - counter
3364 
     - userId
3365 
    """
3366 
    self.send_registerCounter(counter, userId)
3367 
    return self.recv_registerCounter()
11890 kshitij.so 3368 
 
12696 amit.gupta 3369 
  def send_registerCounter(self, counter, userId):
3370 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3371 
    args = registerCounter_args()
3372 
    args.counter = counter
3373 
    args.userId = userId
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_registerCounter(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = registerCounter_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    if result.success is not None:
3389 
      return result.success
3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3391 
 
12722 amit.gupta 3392 
  def searchCounter(self, type1, searchString):
3393 
    """
3394 
    Parameters:
3395 
     - type1
3396 
     - searchString
3397 
    """
3398 
    self.send_searchCounter(type1, searchString)
3399 
    return self.recv_searchCounter()
12696 amit.gupta 3400 
 
12722 amit.gupta 3401 
  def send_searchCounter(self, type1, searchString):
3402 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3403 
    args = searchCounter_args()
3404 
    args.type1 = type1
3405 
    args.searchString = searchString
3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_searchCounter(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = searchCounter_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3420 
    if result.success is not None:
3421 
      return result.success
3422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3423 
 
3424 
  def getAllUsersByCounter(self, counterId):
3425 
    """
3426 
    Parameters:
3427 
     - counterId
3428 
    """
3429 
    self.send_getAllUsersByCounter(counterId)
3430 
    return self.recv_getAllUsersByCounter()
3431 
 
3432 
  def send_getAllUsersByCounter(self, counterId):
3433 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3434 
    args = getAllUsersByCounter_args()
3435 
    args.counterId = counterId
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_getAllUsersByCounter(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = getAllUsersByCounter_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.success is not None:
3451 
      return result.success
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3453 
 
15251 manish.sha 3454 
  def getActiveAccessTokenForUser(self, userId, source):
3455 
    """
3456 
    Parameters:
3457 
     - userId
3458 
     - source
3459 
    """
3460 
    self.send_getActiveAccessTokenForUser(userId, source)
3461 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3462 
 
15251 manish.sha 3463 
  def send_getActiveAccessTokenForUser(self, userId, source):
3464 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3465 
    args = getActiveAccessTokenForUser_args()
3466 
    args.userId = userId
3467 
    args.source = source
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_getActiveAccessTokenForUser(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = getActiveAccessTokenForUser_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3485 
 
3486 
  def validateAccessToken(self, accessToken):
3487 
    """
3488 
    Parameters:
3489 
     - accessToken
3490 
    """
3491 
    self.send_validateAccessToken(accessToken)
3492 
    return self.recv_validateAccessToken()
3493 
 
3494 
  def send_validateAccessToken(self, accessToken):
3495 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3496 
    args = validateAccessToken_args()
3497 
    args.accessToken = accessToken
3498 
    args.write(self._oprot)
3499 
    self._oprot.writeMessageEnd()
3500 
    self._oprot.trans.flush()
3501 
 
3502 
  def recv_validateAccessToken(self, ):
3503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3504 
    if mtype == TMessageType.EXCEPTION:
3505 
      x = TApplicationException()
3506 
      x.read(self._iprot)
3507 
      self._iprot.readMessageEnd()
3508 
      raise x
3509 
    result = validateAccessToken_result()
3510 
    result.read(self._iprot)
3511 
    self._iprot.readMessageEnd()
3512 
    if result.success is not None:
3513 
      return result.success
3514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3515 
 
3516 
 
3376 rajveer 3517 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3518 
  def __init__(self, handler):
3376 rajveer 3519 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3520 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3521 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3522 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3523 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3524 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3525 
    self._processMap["createUser"] = Processor.process_createUser
3526 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3527 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3528 
    self._processMap["userExists"] = Processor.process_userExists
3529 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3530 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3531 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3532 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3533 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3534 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3535 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3536 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3537 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3538 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3539 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3540 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3541 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3542 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3543 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3544 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3545 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3546 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3547 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3548 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3549 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3550 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3551 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3552 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3553 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3554 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3555 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3556 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3557 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3558 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3559 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3560 
    self._processMap["getCart"] = Processor.process_getCart
3561 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3562 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3563 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3564 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3565 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3566 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3567 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3568 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3569 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3570 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3571 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3572 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3573 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3574 
    self._processMap["checkOut"] = Processor.process_checkOut
3575 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3576 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3577 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3578 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3579 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3580 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3581 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3582 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3583 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3584 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3585 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3586 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3587 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3588 
    self._processMap["insureItem"] = Processor.process_insureItem
3589 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3590 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3591 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3592 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3593 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3594 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3595 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3596 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3597 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3598 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3599 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3600 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3601 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3602 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
94 ashish 3603 
 
3604 
  def process(self, iprot, oprot):
3605 
    (name, type, seqid) = iprot.readMessageBegin()
3606 
    if name not in self._processMap:
3607 
      iprot.skip(TType.STRUCT)
3608 
      iprot.readMessageEnd()
3609 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3610 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3611 
      x.write(oprot)
3612 
      oprot.writeMessageEnd()
3613 
      oprot.trans.flush()
3614 
      return
3615 
    else:
3616 
      self._processMap[name](self, seqid, iprot, oprot)
3617 
    return True
3618 
 
559 chandransh 3619 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3620 
    args = createAnonymousUser_args()
94 ashish 3621 
    args.read(iprot)
3622 
    iprot.readMessageEnd()
559 chandransh 3623 
    result = createAnonymousUser_result()
94 ashish 3624 
    try:
559 chandransh 3625 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3626 
    except UserContextException, ucex:
3627 
      result.ucex = ucex
3628 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3629 
    result.write(oprot)
3630 
    oprot.writeMessageEnd()
3631 
    oprot.trans.flush()
3632 
 
559 chandransh 3633 
  def process_getUserById(self, seqid, iprot, oprot):
3634 
    args = getUserById_args()
94 ashish 3635 
    args.read(iprot)
3636 
    iprot.readMessageEnd()
559 chandransh 3637 
    result = getUserById_result()
94 ashish 3638 
    try:
559 chandransh 3639 
      result.success = self._handler.getUserById(args.userId)
3640 
    except UserContextException, ucex:
3641 
      result.ucex = ucex
3642 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3643 
    result.write(oprot)
3644 
    oprot.writeMessageEnd()
3645 
    oprot.trans.flush()
3646 
 
5326 rajveer 3647 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3648 
    args = getUserByCartId_args()
3649 
    args.read(iprot)
3650 
    iprot.readMessageEnd()
3651 
    result = getUserByCartId_result()
3652 
    try:
3653 
      result.success = self._handler.getUserByCartId(args.cartId)
3654 
    except UserContextException, ucex:
3655 
      result.ucex = ucex
3656 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3657 
    result.write(oprot)
3658 
    oprot.writeMessageEnd()
3659 
    oprot.trans.flush()
3660 
 
1491 vikas 3661 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3662 
    args = getUserByEmail_args()
3663 
    args.read(iprot)
3664 
    iprot.readMessageEnd()
3665 
    result = getUserByEmail_result()
3666 
    try:
3667 
      result.success = self._handler.getUserByEmail(args.email)
3668 
    except UserContextException, ucex:
3669 
      result.ucex = ucex
3670 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3671 
    result.write(oprot)
3672 
    oprot.writeMessageEnd()
3673 
    oprot.trans.flush()
3674 
 
3032 mandeep.dh 3675 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3676 
    args = getUserByMobileNumber_args()
3677 
    args.read(iprot)
3678 
    iprot.readMessageEnd()
3679 
    result = getUserByMobileNumber_result()
3680 
    try:
3681 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3682 
    except UserContextException, ucex:
3683 
      result.ucex = ucex
3684 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3685 
    result.write(oprot)
3686 
    oprot.writeMessageEnd()
3687 
    oprot.trans.flush()
3688 
 
559 chandransh 3689 
  def process_createUser(self, seqid, iprot, oprot):
3690 
    args = createUser_args()
94 ashish 3691 
    args.read(iprot)
3692 
    iprot.readMessageEnd()
559 chandransh 3693 
    result = createUser_result()
94 ashish 3694 
    try:
559 chandransh 3695 
      result.success = self._handler.createUser(args.user)
3696 
    except UserContextException, ucex:
3697 
      result.ucex = ucex
3698 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3699 
    result.write(oprot)
3700 
    oprot.writeMessageEnd()
3701 
    oprot.trans.flush()
3702 
 
559 chandransh 3703 
  def process_updateUser(self, seqid, iprot, oprot):
3704 
    args = updateUser_args()
94 ashish 3705 
    args.read(iprot)
3706 
    iprot.readMessageEnd()
559 chandransh 3707 
    result = updateUser_result()
94 ashish 3708 
    try:
559 chandransh 3709 
      result.success = self._handler.updateUser(args.user)
3710 
    except UserContextException, ucex:
3711 
      result.ucex = ucex
3712 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3713 
    result.write(oprot)
3714 
    oprot.writeMessageEnd()
3715 
    oprot.trans.flush()
3716 
 
122 ashish 3717 
  def process_authenticateUser(self, seqid, iprot, oprot):
3718 
    args = authenticateUser_args()
3719 
    args.read(iprot)
3720 
    iprot.readMessageEnd()
3721 
    result = authenticateUser_result()
3722 
    try:
559 chandransh 3723 
      result.success = self._handler.authenticateUser(args.email, args.password)
3724 
    except AuthenticationException, auex:
3725 
      result.auex = auex
122 ashish 3726 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3727 
    result.write(oprot)
3728 
    oprot.writeMessageEnd()
3729 
    oprot.trans.flush()
3730 
 
94 ashish 3731 
  def process_userExists(self, seqid, iprot, oprot):
3732 
    args = userExists_args()
3733 
    args.read(iprot)
3734 
    iprot.readMessageEnd()
3735 
    result = userExists_result()
3736 
    try:
3737 
      result.success = self._handler.userExists(args.email)
3738 
    except UserContextException, ucx:
3739 
      result.ucx = ucx
3740 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3741 
    result.write(oprot)
3742 
    oprot.writeMessageEnd()
3743 
    oprot.trans.flush()
3744 
 
3745 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3746 
    args = addAddressForUser_args()
3747 
    args.read(iprot)
3748 
    iprot.readMessageEnd()
3749 
    result = addAddressForUser_result()
3750 
    try:
567 rajveer 3751 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3752 
    except UserContextException, ucx:
3753 
      result.ucx = ucx
3754 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3755 
    result.write(oprot)
3756 
    oprot.writeMessageEnd()
3757 
    oprot.trans.flush()
3758 
 
3759 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3760 
    args = removeAddressForUser_args()
3761 
    args.read(iprot)
3762 
    iprot.readMessageEnd()
3763 
    result = removeAddressForUser_result()
3764 
    try:
3765 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3766 
    except UserContextException, ucx:
3767 
      result.ucx = ucx
3768 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3769 
    result.write(oprot)
3770 
    oprot.writeMessageEnd()
3771 
    oprot.trans.flush()
3772 
 
3773 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3774 
    args = setUserAsLoggedIn_args()
3775 
    args.read(iprot)
3776 
    iprot.readMessageEnd()
3777 
    result = setUserAsLoggedIn_result()
3778 
    try:
3779 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3780 
    except UserContextException, ucx:
3781 
      result.ucx = ucx
3782 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3783 
    result.write(oprot)
3784 
    oprot.writeMessageEnd()
3785 
    oprot.trans.flush()
3786 
 
3787 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3788 
    args = setUserAsLoggedOut_args()
3789 
    args.read(iprot)
3790 
    iprot.readMessageEnd()
3791 
    result = setUserAsLoggedOut_result()
3792 
    try:
3793 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3794 
    except UserContextException, ucx:
3795 
      result.ucx = ucx
3796 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3797 
    result.write(oprot)
3798 
    oprot.writeMessageEnd()
3799 
    oprot.trans.flush()
3800 
 
504 rajveer 3801 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3802 
    args = setDefaultAddress_args()
3803 
    args.read(iprot)
3804 
    iprot.readMessageEnd()
3805 
    result = setDefaultAddress_result()
3806 
    try:
3807 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3808 
    except UserContextException, ucx:
3809 
      result.ucx = ucx
3810 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3811 
    result.write(oprot)
3812 
    oprot.writeMessageEnd()
3813 
    oprot.trans.flush()
3814 
 
94 ashish 3815 
  def process_updatePassword(self, seqid, iprot, oprot):
3816 
    args = updatePassword_args()
3817 
    args.read(iprot)
3818 
    iprot.readMessageEnd()
3819 
    result = updatePassword_result()
3820 
    try:
594 rajveer 3821 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3822 
    except UserContextException, ucx:
3823 
      result.ucx = ucx
3824 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3825 
    result.write(oprot)
3826 
    oprot.writeMessageEnd()
3827 
    oprot.trans.flush()
3828 
 
581 rajveer 3829 
  def process_forgotPassword(self, seqid, iprot, oprot):
3830 
    args = forgotPassword_args()
3831 
    args.read(iprot)
3832 
    iprot.readMessageEnd()
3833 
    result = forgotPassword_result()
3834 
    try:
884 rajveer 3835 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3836 
    except UserContextException, ucx:
3837 
      result.ucx = ucx
3838 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3839 
    result.write(oprot)
3840 
    oprot.writeMessageEnd()
3841 
    oprot.trans.flush()
3842 
 
594 rajveer 3843 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3844 
    args = getAllAddressesForUser_args()
3845 
    args.read(iprot)
3846 
    iprot.readMessageEnd()
3847 
    result = getAllAddressesForUser_result()
3848 
    try:
3849 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3850 
    except UserContextException, ucx:
3851 
      result.ucx = ucx
3852 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3853 
    result.write(oprot)
3854 
    oprot.writeMessageEnd()
3855 
    oprot.trans.flush()
3856 
 
1894 vikas 3857 
  def process_getAddressById(self, seqid, iprot, oprot):
3858 
    args = getAddressById_args()
3859 
    args.read(iprot)
3860 
    iprot.readMessageEnd()
3861 
    result = getAddressById_result()
3862 
    try:
3863 
      result.success = self._handler.getAddressById(args.addressId)
3864 
    except UserContextException, ucx:
3865 
      result.ucx = ucx
3866 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3867 
    result.write(oprot)
3868 
    oprot.writeMessageEnd()
3869 
    oprot.trans.flush()
3870 
 
594 rajveer 3871 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3872 
    args = getDefaultAddressId_args()
3873 
    args.read(iprot)
3874 
    iprot.readMessageEnd()
3875 
    result = getDefaultAddressId_result()
3876 
    try:
3877 
      result.success = self._handler.getDefaultAddressId(args.userId)
3878 
    except UserContextException, ucx:
3879 
      result.ucx = ucx
3880 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3881 
    result.write(oprot)
3882 
    oprot.writeMessageEnd()
3883 
    oprot.trans.flush()
3884 
 
785 rajveer 3885 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3886 
    args = getDefaultPincode_args()
3887 
    args.read(iprot)
3888 
    iprot.readMessageEnd()
3889 
    result = getDefaultPincode_result()
3890 
    try:
3891 
      result.success = self._handler.getDefaultPincode(args.userId)
3892 
    except UserContextException, ucx:
3893 
      result.ucx = ucx
3894 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3895 
    result.write(oprot)
3896 
    oprot.writeMessageEnd()
3897 
    oprot.trans.flush()
3898 
 
1274 varun.gupt 3899 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3900 
    args = saveUserCommunication_args()
3901 
    args.read(iprot)
3902 
    iprot.readMessageEnd()
3903 
    result = saveUserCommunication_result()
3904 
    try:
3905 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3906 
    except UserCommunicationException, ucx:
3907 
      result.ucx = ucx
3908 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3909 
    result.write(oprot)
3910 
    oprot.writeMessageEnd()
3911 
    oprot.trans.flush()
3912 
 
1590 varun.gupt 3913 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3914 
    args = getUserCommunicationById_args()
3915 
    args.read(iprot)
3916 
    iprot.readMessageEnd()
3917 
    result = getUserCommunicationById_result()
3918 
    try:
3919 
      result.success = self._handler.getUserCommunicationById(args.id)
3920 
    except UserCommunicationException, ucx:
3921 
      result.ucx = ucx
3922 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3923 
    result.write(oprot)
3924 
    oprot.writeMessageEnd()
3925 
    oprot.trans.flush()
3926 
 
3927 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3928 
    args = getUserCommunicationByUser_args()
3929 
    args.read(iprot)
3930 
    iprot.readMessageEnd()
3931 
    result = getUserCommunicationByUser_result()
3932 
    try:
3933 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3934 
    except UserCommunicationException, ucx:
3935 
      result.ucx = ucx
3936 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3937 
    result.write(oprot)
3938 
    oprot.writeMessageEnd()
3939 
    oprot.trans.flush()
3940 
 
3941 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3942 
    args = getAllUserCommunications_args()
3943 
    args.read(iprot)
3944 
    iprot.readMessageEnd()
3945 
    result = getAllUserCommunications_result()
3946 
    try:
3947 
      result.success = self._handler.getAllUserCommunications()
3948 
    except UserCommunicationException, ucx:
3949 
      result.ucx = ucx
3950 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3951 
    result.write(oprot)
3952 
    oprot.writeMessageEnd()
3953 
    oprot.trans.flush()
3954 
 
5407 amar.kumar 3955 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
3956 
    args = removeUserCommunication_args()
3957 
    args.read(iprot)
3958 
    iprot.readMessageEnd()
3959 
    result = removeUserCommunication_result()
3960 
    try:
3961 
      self._handler.removeUserCommunication(args.id)
3962 
    except UserCommunicationException, ucx:
3963 
      result.ucx = ucx
3964 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
3965 
    result.write(oprot)
3966 
    oprot.writeMessageEnd()
3967 
    oprot.trans.flush()
3968 
 
1845 vikas 3969 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3970 
    args = createMasterAffiliate_args()
3971 
    args.read(iprot)
3972 
    iprot.readMessageEnd()
3973 
    result = createMasterAffiliate_result()
3974 
    try:
1859 vikas 3975 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3976 
    except UserAffiliateException, utx:
1845 vikas 3977 
      result.utx = utx
3978 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
3982 
 
1899 vikas 3983 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3984 
    args = getAllMasterAffiliates_args()
3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
3987 
    result = getAllMasterAffiliates_result()
3988 
    try:
3989 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3990 
    except UserAffiliateException, utx:
1899 vikas 3991 
      result.utx = utx
3992 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
1845 vikas 3997 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3998 
    args = getMasterAffiliateById_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = getMasterAffiliateById_result()
4002 
    try:
4003 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4004 
    except UserAffiliateException, utx:
1845 vikas 4005 
      result.utx = utx
4006 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
4011 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4012 
    args = getMasterAffiliateByName_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = getMasterAffiliateByName_result()
4016 
    try:
4017 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4018 
    except UserAffiliateException, utx:
1845 vikas 4019 
      result.utx = utx
4020 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
4025 
  def process_createAffiliate(self, seqid, iprot, oprot):
4026 
    args = createAffiliate_args()
4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
4029 
    result = createAffiliate_result()
4030 
    try:
1859 vikas 4031 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4032 
    except UserAffiliateException, utx:
1845 vikas 4033 
      result.utx = utx
4034 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
4039 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4040 
    args = getAffiliateById_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = getAffiliateById_result()
4044 
    try:
4045 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4046 
    except UserAffiliateException, utx:
1845 vikas 4047 
      result.utx = utx
4048 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
4053 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4054 
    args = getAffiliateByName_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = getAffiliateByName_result()
4058 
    try:
4059 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4060 
    except UserAffiliateException, utx:
1845 vikas 4061 
      result.utx = utx
4062 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
4067 
  def process_getTrackerById(self, seqid, iprot, oprot):
4068 
    args = getTrackerById_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = getTrackerById_result()
4072 
    try:
1996 vikas 4073 
      result.success = self._handler.getTrackerById(args.id)
4074 
    except UserAffiliateException, utx:
1845 vikas 4075 
      result.utx = utx
4076 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
1996 vikas 4081 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4082 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
1996 vikas 4085 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4086 
    try:
1996 vikas 4087 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4088 
    except UserAffiliateException, utx:
1845 vikas 4089 
      result.utx = utx
1996 vikas 4090 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4091 
    result.write(oprot)
4092 
    oprot.writeMessageEnd()
4093 
    oprot.trans.flush()
4094 
 
4095 
  def process_addTrackLog(self, seqid, iprot, oprot):
4096 
    args = addTrackLog_args()
4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
4099 
    result = addTrackLog_result()
4100 
    try:
1996 vikas 4101 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4102 
    except UserAffiliateException, utx:
1845 vikas 4103 
      result.utx = utx
4104 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
4109 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4110 
    args = getTrackLogById_args()
4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
4113 
    result = getTrackLogById_result()
4114 
    try:
4115 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4116 
    except UserAffiliateException, utx:
1845 vikas 4117 
      result.utx = utx
4118 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
1996 vikas 4123 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4124 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
1996 vikas 4127 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4128 
    try:
3293 vikas 4129 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4130 
    except UserAffiliateException, utx:
1845 vikas 4131 
      result.utx = utx
1996 vikas 4132 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
4137 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4138 
    args = getTrackLogsByUser_args()
4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
4141 
    result = getTrackLogsByUser_result()
4142 
    try:
4143 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4144 
    except UserAffiliateException, utx:
1845 vikas 4145 
      result.utx = utx
4146 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4147 
    result.write(oprot)
4148 
    oprot.writeMessageEnd()
4149 
    oprot.trans.flush()
4150 
 
4151 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4152 
    args = getTrackLogs_args()
4153 
    args.read(iprot)
4154 
    iprot.readMessageEnd()
4155 
    result = getTrackLogs_result()
4156 
    try:
1996 vikas 4157 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4158 
    except UserAffiliateException, utx:
1845 vikas 4159 
      result.utx = utx
4160 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4161 
    result.write(oprot)
4162 
    oprot.writeMessageEnd()
4163 
    oprot.trans.flush()
4164 
 
559 chandransh 4165 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4166 
    args = getCurrentCart_args()
94 ashish 4167 
    args.read(iprot)
4168 
    iprot.readMessageEnd()
559 chandransh 4169 
    result = getCurrentCart_result()
94 ashish 4170 
    try:
559 chandransh 4171 
      result.success = self._handler.getCurrentCart(args.userId)
4172 
    except ShoppingCartException, scx:
4173 
      result.scx = scx
4174 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4175 
    result.write(oprot)
4176 
    oprot.writeMessageEnd()
4177 
    oprot.trans.flush()
4178 
 
559 chandransh 4179 
  def process_getCart(self, seqid, iprot, oprot):
4180 
    args = getCart_args()
94 ashish 4181 
    args.read(iprot)
4182 
    iprot.readMessageEnd()
559 chandransh 4183 
    result = getCart_result()
94 ashish 4184 
    try:
559 chandransh 4185 
      result.success = self._handler.getCart(args.cartId)
4186 
    except ShoppingCartException, scx:
4187 
      result.scx = scx
4188 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
4192 
 
559 chandransh 4193 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4194 
    args = getCartsByTime_args()
94 ashish 4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
559 chandransh 4197 
    result = getCartsByTime_result()
94 ashish 4198 
    try:
559 chandransh 4199 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4200 
    except ShoppingCartException, scx:
4201 
      result.scx = scx
4202 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4203 
    result.write(oprot)
4204 
    oprot.writeMessageEnd()
4205 
    oprot.trans.flush()
4206 
 
559 chandransh 4207 
  def process_addItemToCart(self, seqid, iprot, oprot):
4208 
    args = addItemToCart_args()
130 ashish 4209 
    args.read(iprot)
4210 
    iprot.readMessageEnd()
559 chandransh 4211 
    result = addItemToCart_result()
130 ashish 4212 
    try:
3557 rajveer 4213 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4214 
    except ShoppingCartException, scx:
4215 
      result.scx = scx
4216 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4217 
    result.write(oprot)
4218 
    oprot.writeMessageEnd()
4219 
    oprot.trans.flush()
4220 
 
559 chandransh 4221 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4222 
    args = deleteItemFromCart_args()
4223 
    args.read(iprot)
4224 
    iprot.readMessageEnd()
4225 
    result = deleteItemFromCart_result()
4226 
    try:
4227 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4228 
    except ShoppingCartException, scx:
4229 
      result.scx = scx
4230 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4231 
    result.write(oprot)
4232 
    oprot.writeMessageEnd()
4233 
    oprot.trans.flush()
130 ashish 4234 
 
559 chandransh 4235 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4236 
    args = addAddressToCart_args()
4237 
    args.read(iprot)
4238 
    iprot.readMessageEnd()
4239 
    result = addAddressToCart_result()
575 chandransh 4240 
    try:
4241 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4242 
    except ShoppingCartException, scx:
4243 
      result.scx = scx
559 chandransh 4244 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4245 
    result.write(oprot)
4246 
    oprot.writeMessageEnd()
4247 
    oprot.trans.flush()
4248 
 
5553 rajveer 4249 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4250 
    args = addStoreToCart_args()
4251 
    args.read(iprot)
4252 
    iprot.readMessageEnd()
4253 
    result = addStoreToCart_result()
4254 
    try:
4255 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4256 
    except ShoppingCartException, scx:
4257 
      result.scx = scx
4258 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4259 
    result.write(oprot)
4260 
    oprot.writeMessageEnd()
4261 
    oprot.trans.flush()
4262 
 
1976 varun.gupt 4263 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4264 
    args = applyCouponToCart_args()
4265 
    args.read(iprot)
4266 
    iprot.readMessageEnd()
4267 
    result = applyCouponToCart_result()
4268 
    try:
6922 anupam.sin 4269 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4270 
    except ShoppingCartException, scx:
4271 
      result.scx = scx
4272 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4273 
    result.write(oprot)
4274 
    oprot.writeMessageEnd()
4275 
    oprot.trans.flush()
4276 
 
4277 
  def process_removeCoupon(self, seqid, iprot, oprot):
4278 
    args = removeCoupon_args()
4279 
    args.read(iprot)
4280 
    iprot.readMessageEnd()
4281 
    result = removeCoupon_result()
4282 
    try:
4283 
      self._handler.removeCoupon(args.cartId)
4284 
    except ShoppingCartException, scx:
4285 
      result.scx = scx
4286 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4287 
    result.write(oprot)
4288 
    oprot.writeMessageEnd()
4289 
    oprot.trans.flush()
4290 
 
3554 varun.gupt 4291 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4292 
    args = deleteDiscountsFromCart_args()
4293 
    args.read(iprot)
4294 
    iprot.readMessageEnd()
4295 
    result = deleteDiscountsFromCart_result()
4296 
    try:
4297 
      self._handler.deleteDiscountsFromCart(args.cartId)
4298 
    except ShoppingCartException, scx:
4299 
      result.scx = scx
4300 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4301 
    result.write(oprot)
4302 
    oprot.writeMessageEnd()
4303 
    oprot.trans.flush()
4304 
 
4305 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4306 
    args = saveDiscounts_args()
4307 
    args.read(iprot)
4308 
    iprot.readMessageEnd()
4309 
    result = saveDiscounts_result()
4310 
    try:
4311 
      self._handler.saveDiscounts(args.discounts)
4312 
    except ShoppingCartException, scx:
4313 
      result.scx = scx
4314 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4315 
    result.write(oprot)
4316 
    oprot.writeMessageEnd()
4317 
    oprot.trans.flush()
4318 
 
690 chandransh 4319 
  def process_createOrders(self, seqid, iprot, oprot):
4320 
    args = createOrders_args()
559 chandransh 4321 
    args.read(iprot)
4322 
    iprot.readMessageEnd()
690 chandransh 4323 
    result = createOrders_result()
559 chandransh 4324 
    try:
11526 amit.gupta 4325 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4326 
    except ShoppingCartException, scx:
4327 
      result.scx = scx
690 chandransh 4328 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4329 
    result.write(oprot)
4330 
    oprot.writeMessageEnd()
4331 
    oprot.trans.flush()
4332 
 
4333 
  def process_validateCart(self, seqid, iprot, oprot):
4334 
    args = validateCart_args()
4335 
    args.read(iprot)
4336 
    iprot.readMessageEnd()
4337 
    result = validateCart_result()
575 chandransh 4338 
    try:
3557 rajveer 4339 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4340 
    except ShoppingCartException, scex:
4341 
      result.scex = scex
559 chandransh 4342 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4343 
    result.write(oprot)
4344 
    oprot.writeMessageEnd()
4345 
    oprot.trans.flush()
4346 
 
11980 amit.gupta 4347 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4348 
    args = validateCartWithDealerCoupon_args()
4349 
    args.read(iprot)
4350 
    iprot.readMessageEnd()
4351 
    result = validateCartWithDealerCoupon_result()
4352 
    try:
4353 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4354 
    except ShoppingCartException, scex:
4355 
      result.scex = scex
4356 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4357 
    result.write(oprot)
4358 
    oprot.writeMessageEnd()
4359 
    oprot.trans.flush()
4360 
 
690 chandransh 4361 
  def process_mergeCart(self, seqid, iprot, oprot):
4362 
    args = mergeCart_args()
575 chandransh 4363 
    args.read(iprot)
4364 
    iprot.readMessageEnd()
690 chandransh 4365 
    result = mergeCart_result()
4366 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4367 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4368 
    result.write(oprot)
4369 
    oprot.writeMessageEnd()
4370 
    oprot.trans.flush()
4371 
 
4372 
  def process_checkOut(self, seqid, iprot, oprot):
4373 
    args = checkOut_args()
4374 
    args.read(iprot)
4375 
    iprot.readMessageEnd()
4376 
    result = checkOut_result()
575 chandransh 4377 
    try:
690 chandransh 4378 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4379 
    except ShoppingCartException, scex:
4380 
      result.scex = scex
690 chandransh 4381 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4382 
    result.write(oprot)
4383 
    oprot.writeMessageEnd()
4384 
    oprot.trans.flush()
4385 
 
690 chandransh 4386 
  def process_resetCart(self, seqid, iprot, oprot):
4387 
    args = resetCart_args()
559 chandransh 4388 
    args.read(iprot)
4389 
    iprot.readMessageEnd()
690 chandransh 4390 
    result = resetCart_result()
4391 
    try:
4392 
      result.success = self._handler.resetCart(args.cartId, args.items)
4393 
    except ShoppingCartException, scex:
4394 
      result.scex = scex
4395 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
4399 
 
2981 rajveer 4400 
  def process_getUserCount(self, seqid, iprot, oprot):
4401 
    args = getUserCount_args()
559 chandransh 4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
2981 rajveer 4404 
    result = getUserCount_result()
4405 
    result.success = self._handler.getUserCount(args.userType)
4406 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4407 
    result.write(oprot)
4408 
    oprot.writeMessageEnd()
4409 
    oprot.trans.flush()
4410 
 
2981 rajveer 4411 
  def process_getAllUsers(self, seqid, iprot, oprot):
4412 
    args = getAllUsers_args()
559 chandransh 4413 
    args.read(iprot)
4414 
    iprot.readMessageEnd()
2981 rajveer 4415 
    result = getAllUsers_result()
4416 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4417 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
4421 
 
2981 rajveer 4422 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4423 
    args = getMyResearchItems_args()
559 chandransh 4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
2981 rajveer 4426 
    result = getMyResearchItems_result()
559 chandransh 4427 
    try:
2981 rajveer 4428 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4429 
    except WidgetException, scx:
4430 
      result.scx = scx
2981 rajveer 4431 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4432 
    result.write(oprot)
4433 
    oprot.writeMessageEnd()
4434 
    oprot.trans.flush()
4435 
 
2981 rajveer 4436 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4437 
    args = updateMyResearch_args()
772 rajveer 4438 
    args.read(iprot)
4439 
    iprot.readMessageEnd()
2981 rajveer 4440 
    result = updateMyResearch_result()
4441 
    try:
4442 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4443 
    except WidgetException, scx:
4444 
      result.scx = scx
4445 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4446 
    result.write(oprot)
4447 
    oprot.writeMessageEnd()
4448 
    oprot.trans.flush()
559 chandransh 4449 
 
2981 rajveer 4450 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4451 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4452 
    args.read(iprot)
4453 
    iprot.readMessageEnd()
2981 rajveer 4454 
    result = deleteItemFromMyResearch_result()
4455 
    try:
4456 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4457 
    except WidgetException, scx:
4458 
      result.scx = scx
4459 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4460 
    result.write(oprot)
4461 
    oprot.writeMessageEnd()
4462 
    oprot.trans.flush()
772 rajveer 4463 
 
2981 rajveer 4464 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4465 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4466 
    args.read(iprot)
4467 
    iprot.readMessageEnd()
2981 rajveer 4468 
    result = getBrowseHistoryItems_result()
4469 
    try:
4470 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4471 
    except WidgetException, scx:
4472 
      result.scx = scx
4473 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4474 
    result.write(oprot)
4475 
    oprot.writeMessageEnd()
4476 
    oprot.trans.flush()
1596 ankur.sing 4477 
 
2981 rajveer 4478 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4479 
    args = updateBrowseHistory_args()
2642 varun.gupt 4480 
    args.read(iprot)
4481 
    iprot.readMessageEnd()
2981 rajveer 4482 
    result = updateBrowseHistory_result()
4483 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4484 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4485 
    result.write(oprot)
4486 
    oprot.writeMessageEnd()
4487 
    oprot.trans.flush()
1673 ankur.sing 4488 
 
3385 varun.gupt 4489 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4490 
    args = getCartsWithCouponCount_args()
4491 
    args.read(iprot)
4492 
    iprot.readMessageEnd()
4493 
    result = getCartsWithCouponCount_result()
4494 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4495 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4496 
    result.write(oprot)
4497 
    oprot.writeMessageEnd()
4498 
    oprot.trans.flush()
2642 varun.gupt 4499 
 
3499 mandeep.dh 4500 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4501 
    args = increaseTrustLevel_args()
4502 
    args.read(iprot)
4503 
    iprot.readMessageEnd()
4504 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4505 
    return
3385 varun.gupt 4506 
 
5407 amar.kumar 4507 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4508 
    args = getTrustLevel_args()
4509 
    args.read(iprot)
4510 
    iprot.readMessageEnd()
4511 
    result = getTrustLevel_result()
4512 
    result.success = self._handler.getTrustLevel(args.userId)
4513 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4514 
    result.write(oprot)
4515 
    oprot.writeMessageEnd()
4516 
    oprot.trans.flush()
4517 
 
4668 varun.gupt 4518 
  def process_showCODOption(self, seqid, iprot, oprot):
4519 
    args = showCODOption_args()
4520 
    args.read(iprot)
4521 
    iprot.readMessageEnd()
4522 
    result = showCODOption_result()
4523 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4524 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4525 
    result.write(oprot)
4526 
    oprot.writeMessageEnd()
4527 
    oprot.trans.flush()
3499 mandeep.dh 4528 
 
5623 anupam.sin 4529 
  def process_getUserEmails(self, seqid, iprot, oprot):
4530 
    args = getUserEmails_args()
4531 
    args.read(iprot)
4532 
    iprot.readMessageEnd()
4533 
    result = getUserEmails_result()
4534 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4535 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4536 
    result.write(oprot)
4537 
    oprot.writeMessageEnd()
4538 
    oprot.trans.flush()
4668 varun.gupt 4539 
 
6903 anupam.sin 4540 
  def process_insureItem(self, seqid, iprot, oprot):
4541 
    args = insureItem_args()
4542 
    args.read(iprot)
4543 
    iprot.readMessageEnd()
4544 
    result = insureItem_result()
9299 kshitij.so 4545 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4546 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4547 
    result.write(oprot)
4548 
    oprot.writeMessageEnd()
4549 
    oprot.trans.flush()
4550 
 
4551 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4552 
    args = cancelInsurance_args()
4553 
    args.read(iprot)
4554 
    iprot.readMessageEnd()
4555 
    result = cancelInsurance_result()
4556 
    result.success = self._handler.cancelInsurance(args.cartId)
4557 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4558 
    result.write(oprot)
4559 
    oprot.writeMessageEnd()
4560 
    oprot.trans.flush()
4561 
 
4562 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4563 
    args = storeInsuranceSpecificDetails_args()
4564 
    args.read(iprot)
4565 
    iprot.readMessageEnd()
4566 
    result = storeInsuranceSpecificDetails_result()
4567 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4568 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
4573 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4574 
    args = isInsuranceDetailPresent_args()
4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
4577 
    result = isInsuranceDetailPresent_result()
4578 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4579 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4580 
    result.write(oprot)
4581 
    oprot.writeMessageEnd()
4582 
    oprot.trans.flush()
4583 
 
9791 rajveer 4584 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4585 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4586 
    args.read(iprot)
4587 
    iprot.readMessageEnd()
9791 rajveer 4588 
    result = getProductsAddedToCart_result()
4589 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4590 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4591 
    result.write(oprot)
4592 
    oprot.writeMessageEnd()
4593 
    oprot.trans.flush()
5623 anupam.sin 4594 
 
11592 amit.gupta 4595 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4596 
    args = validateCartPlus_args()
4597 
    args.read(iprot)
4598 
    iprot.readMessageEnd()
4599 
    result = validateCartPlus_result()
4600 
    try:
11980 amit.gupta 4601 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4602 
    except ShoppingCartException, scex:
4603 
      result.scex = scex
4604 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
6821 amar.kumar 4608 
 
11679 vikram.rag 4609 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4610 
    args = isPrivateDealUser_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = isPrivateDealUser_result()
4614 
    result.success = self._handler.isPrivateDealUser(args.userId)
4615 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4616 
    result.write(oprot)
4617 
    oprot.writeMessageEnd()
4618 
    oprot.trans.flush()
11592 amit.gupta 4619 
 
11890 kshitij.so 4620 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4621 
    args = addPrivateDealUser_args()
4622 
    args.read(iprot)
4623 
    iprot.readMessageEnd()
4624 
    result = addPrivateDealUser_result()
4625 
    result.success = self._handler.addPrivateDealUser(args.userId)
4626 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4627 
    result.write(oprot)
4628 
    oprot.writeMessageEnd()
4629 
    oprot.trans.flush()
11679 vikram.rag 4630 
 
11890 kshitij.so 4631 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4632 
    args = changePrivateDealUserStatus_args()
4633 
    args.read(iprot)
4634 
    iprot.readMessageEnd()
4635 
    result = changePrivateDealUserStatus_result()
4636 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4637 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4638 
    result.write(oprot)
4639 
    oprot.writeMessageEnd()
4640 
    oprot.trans.flush()
4641 
 
4642 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4643 
    args = getPrivateDealUser_args()
4644 
    args.read(iprot)
4645 
    iprot.readMessageEnd()
4646 
    result = getPrivateDealUser_result()
4647 
    result.success = self._handler.getPrivateDealUser(args.userId)
4648 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
4652 
 
12696 amit.gupta 4653 
  def process_registerCounter(self, seqid, iprot, oprot):
4654 
    args = registerCounter_args()
4655 
    args.read(iprot)
4656 
    iprot.readMessageEnd()
4657 
    result = registerCounter_result()
4658 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4659 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
11890 kshitij.so 4663 
 
12722 amit.gupta 4664 
  def process_searchCounter(self, seqid, iprot, oprot):
4665 
    args = searchCounter_args()
4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
4668 
    result = searchCounter_result()
4669 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4670 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4671 
    result.write(oprot)
4672 
    oprot.writeMessageEnd()
4673 
    oprot.trans.flush()
12696 amit.gupta 4674 
 
12722 amit.gupta 4675 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4676 
    args = getAllUsersByCounter_args()
4677 
    args.read(iprot)
4678 
    iprot.readMessageEnd()
4679 
    result = getAllUsersByCounter_result()
4680 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4681 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4682 
    result.write(oprot)
4683 
    oprot.writeMessageEnd()
4684 
    oprot.trans.flush()
4685 
 
15251 manish.sha 4686 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4687 
    args = getActiveAccessTokenForUser_args()
4688 
    args.read(iprot)
4689 
    iprot.readMessageEnd()
4690 
    result = getActiveAccessTokenForUser_result()
4691 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4692 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4693 
    result.write(oprot)
4694 
    oprot.writeMessageEnd()
4695 
    oprot.trans.flush()
12722 amit.gupta 4696 
 
15251 manish.sha 4697 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4698 
    args = validateAccessToken_args()
4699 
    args.read(iprot)
4700 
    iprot.readMessageEnd()
4701 
    result = validateAccessToken_result()
4702 
    result.success = self._handler.validateAccessToken(args.accessToken)
4703 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4704 
    result.write(oprot)
4705 
    oprot.writeMessageEnd()
4706 
    oprot.trans.flush()
4707 
 
4708 
 
94 ashish 4709 
# HELPER FUNCTIONS AND STRUCTURES
4710 
 
559 chandransh 4711 
class createAnonymousUser_args:
94 ashish 4712 
  """
4713 
  Attributes:
559 chandransh 4714 
   - jsessionId
94 ashish 4715 
  """
4716 
 
4717 
  thrift_spec = (
4718 
    None, # 0
559 chandransh 4719 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4720 
  )
4721 
 
559 chandransh 4722 
  def __init__(self, jsessionId=None,):
4723 
    self.jsessionId = jsessionId
94 ashish 4724 
 
4725 
  def read(self, iprot):
4726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4728 
      return
4729 
    iprot.readStructBegin()
4730 
    while True:
4731 
      (fname, ftype, fid) = iprot.readFieldBegin()
4732 
      if ftype == TType.STOP:
4733 
        break
4734 
      if fid == 1:
559 chandransh 4735 
        if ftype == TType.STRING:
4736 
          self.jsessionId = iprot.readString();
94 ashish 4737 
        else:
4738 
          iprot.skip(ftype)
4739 
      else:
4740 
        iprot.skip(ftype)
4741 
      iprot.readFieldEnd()
4742 
    iprot.readStructEnd()
4743 
 
4744 
  def write(self, oprot):
4745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4747 
      return
559 chandransh 4748 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4749 
    if self.jsessionId is not None:
559 chandransh 4750 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4751 
      oprot.writeString(self.jsessionId)
94 ashish 4752 
      oprot.writeFieldEnd()
4753 
    oprot.writeFieldStop()
4754 
    oprot.writeStructEnd()
4755 
 
3431 rajveer 4756 
  def validate(self):
4757 
    return
4758 
 
4759 
 
94 ashish 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 createAnonymousUser_result:
94 ashish 4772 
  """
4773 
  Attributes:
4774 
   - success
559 chandransh 4775 
   - ucex
94 ashish 4776 
  """
4777 
 
4778 
  thrift_spec = (
559 chandransh 4779 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), 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:
4797 
        if ftype == TType.STRUCT:
559 chandransh 4798 
          self.success = User()
94 ashish 4799 
          self.success.read(iprot)
4800 
        else:
4801 
          iprot.skip(ftype)
4802 
      elif fid == 1:
4803 
        if ftype == TType.STRUCT:
559 chandransh 4804 
          self.ucex = UserContextException()
4805 
          self.ucex.read(iprot)
94 ashish 4806 
        else:
4807 
          iprot.skip(ftype)
4808 
      else:
4809 
        iprot.skip(ftype)
4810 
      iprot.readFieldEnd()
4811 
    iprot.readStructEnd()
4812 
 
4813 
  def write(self, oprot):
4814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4816 
      return
559 chandransh 4817 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4818 
    if self.success is not None:
94 ashish 4819 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4820 
      self.success.write(oprot)
4821 
      oprot.writeFieldEnd()
3431 rajveer 4822 
    if self.ucex is not None:
559 chandransh 4823 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4824 
      self.ucex.write(oprot)
94 ashish 4825 
      oprot.writeFieldEnd()
4826 
    oprot.writeFieldStop()
4827 
    oprot.writeStructEnd()
4828 
 
3431 rajveer 4829 
  def validate(self):
4830 
    return
4831 
 
4832 
 
94 ashish 4833 
  def __repr__(self):
4834 
    L = ['%s=%r' % (key, value)
4835 
      for key, value in self.__dict__.iteritems()]
4836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4837 
 
4838 
  def __eq__(self, other):
4839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4840 
 
4841 
  def __ne__(self, other):
4842 
    return not (self == other)
4843 
 
559 chandransh 4844 
class getUserById_args:
94 ashish 4845 
  """
4846 
  Attributes:
4847 
   - userId
4848 
  """
4849 
 
4850 
  thrift_spec = (
4851 
    None, # 0
4852 
    (1, TType.I64, 'userId', None, None, ), # 1
4853 
  )
4854 
 
559 chandransh 4855 
  def __init__(self, userId=None,):
94 ashish 4856 
    self.userId = userId
4857 
 
4858 
  def read(self, iprot):
4859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4861 
      return
4862 
    iprot.readStructBegin()
4863 
    while True:
4864 
      (fname, ftype, fid) = iprot.readFieldBegin()
4865 
      if ftype == TType.STOP:
4866 
        break
4867 
      if fid == 1:
4868 
        if ftype == TType.I64:
4869 
          self.userId = iprot.readI64();
4870 
        else:
4871 
          iprot.skip(ftype)
4872 
      else:
4873 
        iprot.skip(ftype)
4874 
      iprot.readFieldEnd()
4875 
    iprot.readStructEnd()
4876 
 
4877 
  def write(self, oprot):
4878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4880 
      return
559 chandransh 4881 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4882 
    if self.userId is not None:
94 ashish 4883 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4884 
      oprot.writeI64(self.userId)
4885 
      oprot.writeFieldEnd()
4886 
    oprot.writeFieldStop()
4887 
    oprot.writeStructEnd()
4888 
 
3431 rajveer 4889 
  def validate(self):
4890 
    return
4891 
 
4892 
 
94 ashish 4893 
  def __repr__(self):
4894 
    L = ['%s=%r' % (key, value)
4895 
      for key, value in self.__dict__.iteritems()]
4896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4897 
 
4898 
  def __eq__(self, other):
4899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4900 
 
4901 
  def __ne__(self, other):
4902 
    return not (self == other)
4903 
 
559 chandransh 4904 
class getUserById_result:
94 ashish 4905 
  """
4906 
  Attributes:
4907 
   - success
559 chandransh 4908 
   - ucex
94 ashish 4909 
  """
4910 
 
4911 
  thrift_spec = (
559 chandransh 4912 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4913 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4914 
  )
4915 
 
559 chandransh 4916 
  def __init__(self, success=None, ucex=None,):
94 ashish 4917 
    self.success = success
559 chandransh 4918 
    self.ucex = ucex
94 ashish 4919 
 
4920 
  def read(self, iprot):
4921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4923 
      return
4924 
    iprot.readStructBegin()
4925 
    while True:
4926 
      (fname, ftype, fid) = iprot.readFieldBegin()
4927 
      if ftype == TType.STOP:
4928 
        break
4929 
      if fid == 0:
4930 
        if ftype == TType.STRUCT:
559 chandransh 4931 
          self.success = User()
94 ashish 4932 
          self.success.read(iprot)
4933 
        else:
4934 
          iprot.skip(ftype)
4935 
      elif fid == 1:
4936 
        if ftype == TType.STRUCT:
559 chandransh 4937 
          self.ucex = UserContextException()
4938 
          self.ucex.read(iprot)
94 ashish 4939 
        else:
4940 
          iprot.skip(ftype)
4941 
      else:
4942 
        iprot.skip(ftype)
4943 
      iprot.readFieldEnd()
4944 
    iprot.readStructEnd()
4945 
 
4946 
  def write(self, oprot):
4947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4949 
      return
559 chandransh 4950 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 4951 
    if self.success is not None:
94 ashish 4952 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4953 
      self.success.write(oprot)
4954 
      oprot.writeFieldEnd()
3431 rajveer 4955 
    if self.ucex is not None:
559 chandransh 4956 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4957 
      self.ucex.write(oprot)
94 ashish 4958 
      oprot.writeFieldEnd()
4959 
    oprot.writeFieldStop()
4960 
    oprot.writeStructEnd()
4961 
 
3431 rajveer 4962 
  def validate(self):
4963 
    return
4964 
 
4965 
 
94 ashish 4966 
  def __repr__(self):
4967 
    L = ['%s=%r' % (key, value)
4968 
      for key, value in self.__dict__.iteritems()]
4969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4970 
 
4971 
  def __eq__(self, other):
4972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4973 
 
4974 
  def __ne__(self, other):
4975 
    return not (self == other)
4976 
 
5326 rajveer 4977 
class getUserByCartId_args:
1491 vikas 4978 
  """
4979 
  Attributes:
5326 rajveer 4980 
   - cartId
1491 vikas 4981 
  """
4982 
 
4983 
  thrift_spec = (
4984 
    None, # 0
5326 rajveer 4985 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 4986 
  )
4987 
 
5326 rajveer 4988 
  def __init__(self, cartId=None,):
4989 
    self.cartId = cartId
1491 vikas 4990 
 
4991 
  def read(self, iprot):
4992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4994 
      return
4995 
    iprot.readStructBegin()
4996 
    while True:
4997 
      (fname, ftype, fid) = iprot.readFieldBegin()
4998 
      if ftype == TType.STOP:
4999 
        break
5000 
      if fid == 1:
5326 rajveer 5001 
        if ftype == TType.I64:
5002 
          self.cartId = iprot.readI64();
1491 vikas 5003 
        else:
5004 
          iprot.skip(ftype)
5005 
      else:
5006 
        iprot.skip(ftype)
5007 
      iprot.readFieldEnd()
5008 
    iprot.readStructEnd()
5009 
 
5010 
  def write(self, oprot):
5011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5013 
      return
5326 rajveer 5014 
    oprot.writeStructBegin('getUserByCartId_args')
5015 
    if self.cartId is not None:
5016 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5017 
      oprot.writeI64(self.cartId)
1491 vikas 5018 
      oprot.writeFieldEnd()
5019 
    oprot.writeFieldStop()
5020 
    oprot.writeStructEnd()
5021 
 
3431 rajveer 5022 
  def validate(self):
5023 
    return
5024 
 
5025 
 
1491 vikas 5026 
  def __repr__(self):
5027 
    L = ['%s=%r' % (key, value)
5028 
      for key, value in self.__dict__.iteritems()]
5029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5030 
 
5031 
  def __eq__(self, other):
5032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5033 
 
5034 
  def __ne__(self, other):
5035 
    return not (self == other)
5036 
 
5326 rajveer 5037 
class getUserByCartId_result:
1491 vikas 5038 
  """
5039 
  Attributes:
5040 
   - success
5041 
   - ucex
5042 
  """
5043 
 
5044 
  thrift_spec = (
5045 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5046 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5047 
  )
5048 
 
5049 
  def __init__(self, success=None, ucex=None,):
5050 
    self.success = success
5051 
    self.ucex = ucex
5052 
 
5053 
  def read(self, iprot):
5054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5056 
      return
5057 
    iprot.readStructBegin()
5058 
    while True:
5059 
      (fname, ftype, fid) = iprot.readFieldBegin()
5060 
      if ftype == TType.STOP:
5061 
        break
5062 
      if fid == 0:
5063 
        if ftype == TType.STRUCT:
5064 
          self.success = User()
5065 
          self.success.read(iprot)
5066 
        else:
5067 
          iprot.skip(ftype)
5068 
      elif fid == 1:
5069 
        if ftype == TType.STRUCT:
5070 
          self.ucex = UserContextException()
5071 
          self.ucex.read(iprot)
5072 
        else:
5073 
          iprot.skip(ftype)
5074 
      else:
5075 
        iprot.skip(ftype)
5076 
      iprot.readFieldEnd()
5077 
    iprot.readStructEnd()
5078 
 
5079 
  def write(self, oprot):
5080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5082 
      return
5326 rajveer 5083 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5084 
    if self.success is not None:
1491 vikas 5085 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5086 
      self.success.write(oprot)
5087 
      oprot.writeFieldEnd()
3431 rajveer 5088 
    if self.ucex is not None:
1491 vikas 5089 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5090 
      self.ucex.write(oprot)
5091 
      oprot.writeFieldEnd()
5092 
    oprot.writeFieldStop()
5093 
    oprot.writeStructEnd()
5094 
 
3431 rajveer 5095 
  def validate(self):
5096 
    return
5097 
 
5098 
 
1491 vikas 5099 
  def __repr__(self):
5100 
    L = ['%s=%r' % (key, value)
5101 
      for key, value in self.__dict__.iteritems()]
5102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5103 
 
5104 
  def __eq__(self, other):
5105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5106 
 
5107 
  def __ne__(self, other):
5108 
    return not (self == other)
5109 
 
5326 rajveer 5110 
class getUserByEmail_args:
3032 mandeep.dh 5111 
  """
5112 
  Attributes:
5326 rajveer 5113 
   - email
3032 mandeep.dh 5114 
  """
5115 
 
5116 
  thrift_spec = (
5117 
    None, # 0
5326 rajveer 5118 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5119 
  )
5120 
 
5326 rajveer 5121 
  def __init__(self, email=None,):
5122 
    self.email = email
3032 mandeep.dh 5123 
 
5124 
  def read(self, iprot):
5125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5127 
      return
5128 
    iprot.readStructBegin()
5129 
    while True:
5130 
      (fname, ftype, fid) = iprot.readFieldBegin()
5131 
      if ftype == TType.STOP:
5132 
        break
5133 
      if fid == 1:
5326 rajveer 5134 
        if ftype == TType.STRING:
5135 
          self.email = iprot.readString();
3032 mandeep.dh 5136 
        else:
5137 
          iprot.skip(ftype)
5138 
      else:
5139 
        iprot.skip(ftype)
5140 
      iprot.readFieldEnd()
5141 
    iprot.readStructEnd()
5142 
 
5143 
  def write(self, oprot):
5144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5146 
      return
5326 rajveer 5147 
    oprot.writeStructBegin('getUserByEmail_args')
5148 
    if self.email is not None:
5149 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5150 
      oprot.writeString(self.email)
3032 mandeep.dh 5151 
      oprot.writeFieldEnd()
5152 
    oprot.writeFieldStop()
5153 
    oprot.writeStructEnd()
5154 
 
3431 rajveer 5155 
  def validate(self):
5156 
    return
5157 
 
5158 
 
3032 mandeep.dh 5159 
  def __repr__(self):
5160 
    L = ['%s=%r' % (key, value)
5161 
      for key, value in self.__dict__.iteritems()]
5162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5163 
 
5164 
  def __eq__(self, other):
5165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5166 
 
5167 
  def __ne__(self, other):
5168 
    return not (self == other)
5169 
 
5326 rajveer 5170 
class getUserByEmail_result:
3032 mandeep.dh 5171 
  """
5172 
  Attributes:
5173 
   - success
5174 
   - ucex
5175 
  """
5176 
 
5177 
  thrift_spec = (
5178 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5179 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5180 
  )
5181 
 
5182 
  def __init__(self, success=None, ucex=None,):
5183 
    self.success = success
5184 
    self.ucex = ucex
5185 
 
5186 
  def read(self, iprot):
5187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5189 
      return
5190 
    iprot.readStructBegin()
5191 
    while True:
5192 
      (fname, ftype, fid) = iprot.readFieldBegin()
5193 
      if ftype == TType.STOP:
5194 
        break
5195 
      if fid == 0:
5196 
        if ftype == TType.STRUCT:
5197 
          self.success = User()
5198 
          self.success.read(iprot)
5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      elif fid == 1:
5202 
        if ftype == TType.STRUCT:
5203 
          self.ucex = UserContextException()
5204 
          self.ucex.read(iprot)
5205 
        else:
5206 
          iprot.skip(ftype)
5207 
      else:
5208 
        iprot.skip(ftype)
5209 
      iprot.readFieldEnd()
5210 
    iprot.readStructEnd()
5211 
 
5212 
  def write(self, oprot):
5213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5215 
      return
5326 rajveer 5216 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5217 
    if self.success is not None:
3032 mandeep.dh 5218 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5219 
      self.success.write(oprot)
5220 
      oprot.writeFieldEnd()
3431 rajveer 5221 
    if self.ucex is not None:
3032 mandeep.dh 5222 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5223 
      self.ucex.write(oprot)
5224 
      oprot.writeFieldEnd()
5225 
    oprot.writeFieldStop()
5226 
    oprot.writeStructEnd()
5227 
 
3431 rajveer 5228 
  def validate(self):
5229 
    return
5230 
 
5231 
 
3032 mandeep.dh 5232 
  def __repr__(self):
5233 
    L = ['%s=%r' % (key, value)
5234 
      for key, value in self.__dict__.iteritems()]
5235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5236 
 
5237 
  def __eq__(self, other):
5238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5239 
 
5240 
  def __ne__(self, other):
5241 
    return not (self == other)
5242 
 
5326 rajveer 5243 
class getUserByMobileNumber_args:
94 ashish 5244 
  """
5245 
  Attributes:
5326 rajveer 5246 
   - mobileNumber
94 ashish 5247 
  """
5248 
 
5249 
  thrift_spec = (
5250 
    None, # 0
5326 rajveer 5251 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5252 
  )
5253 
 
5326 rajveer 5254 
  def __init__(self, mobileNumber=None,):
5255 
    self.mobileNumber = mobileNumber
94 ashish 5256 
 
5257 
  def read(self, iprot):
5258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5260 
      return
5261 
    iprot.readStructBegin()
5262 
    while True:
5263 
      (fname, ftype, fid) = iprot.readFieldBegin()
5264 
      if ftype == TType.STOP:
5265 
        break
5266 
      if fid == 1:
5326 rajveer 5267 
        if ftype == TType.I64:
5268 
          self.mobileNumber = iprot.readI64();
94 ashish 5269 
        else:
5270 
          iprot.skip(ftype)
5271 
      else:
5272 
        iprot.skip(ftype)
5273 
      iprot.readFieldEnd()
5274 
    iprot.readStructEnd()
5275 
 
5276 
  def write(self, oprot):
5277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5279 
      return
5326 rajveer 5280 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5281 
    if self.mobileNumber is not None:
5282 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5283 
      oprot.writeI64(self.mobileNumber)
94 ashish 5284 
      oprot.writeFieldEnd()
5285 
    oprot.writeFieldStop()
5286 
    oprot.writeStructEnd()
5287 
 
3431 rajveer 5288 
  def validate(self):
5289 
    return
5290 
 
5291 
 
94 ashish 5292 
  def __repr__(self):
5293 
    L = ['%s=%r' % (key, value)
5294 
      for key, value in self.__dict__.iteritems()]
5295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5296 
 
5297 
  def __eq__(self, other):
5298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5299 
 
5300 
  def __ne__(self, other):
5301 
    return not (self == other)
5302 
 
5326 rajveer 5303 
class getUserByMobileNumber_result:
94 ashish 5304 
  """
5305 
  Attributes:
5306 
   - success
559 chandransh 5307 
   - ucex
94 ashish 5308 
  """
5309 
 
5310 
  thrift_spec = (
559 chandransh 5311 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5312 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5313 
  )
5314 
 
559 chandransh 5315 
  def __init__(self, success=None, ucex=None,):
94 ashish 5316 
    self.success = success
559 chandransh 5317 
    self.ucex = ucex
94 ashish 5318 
 
5319 
  def read(self, iprot):
5320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5322 
      return
5323 
    iprot.readStructBegin()
5324 
    while True:
5325 
      (fname, ftype, fid) = iprot.readFieldBegin()
5326 
      if ftype == TType.STOP:
5327 
        break
5328 
      if fid == 0:
5329 
        if ftype == TType.STRUCT:
559 chandransh 5330 
          self.success = User()
94 ashish 5331 
          self.success.read(iprot)
5332 
        else:
5333 
          iprot.skip(ftype)
5334 
      elif fid == 1:
5335 
        if ftype == TType.STRUCT:
559 chandransh 5336 
          self.ucex = UserContextException()
5337 
          self.ucex.read(iprot)
94 ashish 5338 
        else:
5339 
          iprot.skip(ftype)
5340 
      else:
5341 
        iprot.skip(ftype)
5342 
      iprot.readFieldEnd()
5343 
    iprot.readStructEnd()
5344 
 
5345 
  def write(self, oprot):
5346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5348 
      return
5326 rajveer 5349 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5350 
    if self.success is not None:
94 ashish 5351 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5352 
      self.success.write(oprot)
5353 
      oprot.writeFieldEnd()
3431 rajveer 5354 
    if self.ucex is not None:
559 chandransh 5355 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5356 
      self.ucex.write(oprot)
94 ashish 5357 
      oprot.writeFieldEnd()
5358 
    oprot.writeFieldStop()
5359 
    oprot.writeStructEnd()
5360 
 
3431 rajveer 5361 
  def validate(self):
5362 
    return
5363 
 
5364 
 
94 ashish 5365 
  def __repr__(self):
5366 
    L = ['%s=%r' % (key, value)
5367 
      for key, value in self.__dict__.iteritems()]
5368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5369 
 
5370 
  def __eq__(self, other):
5371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5372 
 
5373 
  def __ne__(self, other):
5374 
    return not (self == other)
5375 
 
5326 rajveer 5376 
class createUser_args:
94 ashish 5377 
  """
5378 
  Attributes:
559 chandransh 5379 
   - user
94 ashish 5380 
  """
5381 
 
5382 
  thrift_spec = (
5383 
    None, # 0
559 chandransh 5384 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5385 
  )
5386 
 
559 chandransh 5387 
  def __init__(self, user=None,):
5388 
    self.user = user
94 ashish 5389 
 
5390 
  def read(self, iprot):
5391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5393 
      return
5394 
    iprot.readStructBegin()
5395 
    while True:
5396 
      (fname, ftype, fid) = iprot.readFieldBegin()
5397 
      if ftype == TType.STOP:
5398 
        break
5399 
      if fid == 1:
559 chandransh 5400 
        if ftype == TType.STRUCT:
5401 
          self.user = User()
5402 
          self.user.read(iprot)
94 ashish 5403 
        else:
5404 
          iprot.skip(ftype)
5405 
      else:
5406 
        iprot.skip(ftype)
5407 
      iprot.readFieldEnd()
5408 
    iprot.readStructEnd()
5409 
 
5410 
  def write(self, oprot):
5411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5413 
      return
5326 rajveer 5414 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5415 
    if self.user is not None:
559 chandransh 5416 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5417 
      self.user.write(oprot)
94 ashish 5418 
      oprot.writeFieldEnd()
5419 
    oprot.writeFieldStop()
5420 
    oprot.writeStructEnd()
5421 
 
3431 rajveer 5422 
  def validate(self):
5423 
    return
5424 
 
5425 
 
94 ashish 5426 
  def __repr__(self):
5427 
    L = ['%s=%r' % (key, value)
5428 
      for key, value in self.__dict__.iteritems()]
5429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5430 
 
5431 
  def __eq__(self, other):
5432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5433 
 
5434 
  def __ne__(self, other):
5435 
    return not (self == other)
5436 
 
5326 rajveer 5437 
class createUser_result:
94 ashish 5438 
  """
5439 
  Attributes:
5440 
   - success
559 chandransh 5441 
   - ucex
94 ashish 5442 
  """
5443 
 
5444 
  thrift_spec = (
559 chandransh 5445 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5446 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5447 
  )
5448 
 
559 chandransh 5449 
  def __init__(self, success=None, ucex=None,):
94 ashish 5450 
    self.success = success
559 chandransh 5451 
    self.ucex = ucex
94 ashish 5452 
 
5453 
  def read(self, iprot):
5454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5456 
      return
5457 
    iprot.readStructBegin()
5458 
    while True:
5459 
      (fname, ftype, fid) = iprot.readFieldBegin()
5460 
      if ftype == TType.STOP:
5461 
        break
5462 
      if fid == 0:
5463 
        if ftype == TType.STRUCT:
559 chandransh 5464 
          self.success = User()
94 ashish 5465 
          self.success.read(iprot)
5466 
        else:
5467 
          iprot.skip(ftype)
5468 
      elif fid == 1:
5469 
        if ftype == TType.STRUCT:
559 chandransh 5470 
          self.ucex = UserContextException()
5471 
          self.ucex.read(iprot)
94 ashish 5472 
        else:
5473 
          iprot.skip(ftype)
5474 
      else:
5475 
        iprot.skip(ftype)
5476 
      iprot.readFieldEnd()
5477 
    iprot.readStructEnd()
5478 
 
5479 
  def write(self, oprot):
5480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5482 
      return
5326 rajveer 5483 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5484 
    if self.success is not None:
94 ashish 5485 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5486 
      self.success.write(oprot)
5487 
      oprot.writeFieldEnd()
3431 rajveer 5488 
    if self.ucex is not None:
559 chandransh 5489 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5490 
      self.ucex.write(oprot)
94 ashish 5491 
      oprot.writeFieldEnd()
5492 
    oprot.writeFieldStop()
5493 
    oprot.writeStructEnd()
5494 
 
3431 rajveer 5495 
  def validate(self):
5496 
    return
5497 
 
5498 
 
94 ashish 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 
 
5326 rajveer 5510 
class updateUser_args:
94 ashish 5511 
  """
5512 
  Attributes:
5326 rajveer 5513 
   - user
94 ashish 5514 
  """
5515 
 
5516 
  thrift_spec = (
5517 
    None, # 0
5326 rajveer 5518 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5519 
  )
5520 
 
5326 rajveer 5521 
  def __init__(self, user=None,):
5522 
    self.user = user
94 ashish 5523 
 
5524 
  def read(self, iprot):
5525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5527 
      return
5528 
    iprot.readStructBegin()
5529 
    while True:
5530 
      (fname, ftype, fid) = iprot.readFieldBegin()
5531 
      if ftype == TType.STOP:
5532 
        break
5533 
      if fid == 1:
5326 rajveer 5534 
        if ftype == TType.STRUCT:
5535 
          self.user = User()
5536 
          self.user.read(iprot)
94 ashish 5537 
        else:
5538 
          iprot.skip(ftype)
5539 
      else:
5540 
        iprot.skip(ftype)
5541 
      iprot.readFieldEnd()
5542 
    iprot.readStructEnd()
5543 
 
5544 
  def write(self, oprot):
5545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5547 
      return
5326 rajveer 5548 
    oprot.writeStructBegin('updateUser_args')
5549 
    if self.user is not None:
5550 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5551 
      self.user.write(oprot)
94 ashish 5552 
      oprot.writeFieldEnd()
5553 
    oprot.writeFieldStop()
5554 
    oprot.writeStructEnd()
5555 
 
3431 rajveer 5556 
  def validate(self):
5557 
    return
5558 
 
5559 
 
94 ashish 5560 
  def __repr__(self):
5561 
    L = ['%s=%r' % (key, value)
5562 
      for key, value in self.__dict__.iteritems()]
5563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5564 
 
5565 
  def __eq__(self, other):
5566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5567 
 
5568 
  def __ne__(self, other):
5569 
    return not (self == other)
5570 
 
5326 rajveer 5571 
class updateUser_result:
94 ashish 5572 
  """
5573 
  Attributes:
5574 
   - success
559 chandransh 5575 
   - ucex
94 ashish 5576 
  """
5577 
 
5578 
  thrift_spec = (
5326 rajveer 5579 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5580 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5581 
  )
5582 
 
559 chandransh 5583 
  def __init__(self, success=None, ucex=None,):
94 ashish 5584 
    self.success = success
559 chandransh 5585 
    self.ucex = ucex
94 ashish 5586 
 
5587 
  def read(self, iprot):
5588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5590 
      return
5591 
    iprot.readStructBegin()
5592 
    while True:
5593 
      (fname, ftype, fid) = iprot.readFieldBegin()
5594 
      if ftype == TType.STOP:
5595 
        break
5596 
      if fid == 0:
5326 rajveer 5597 
        if ftype == TType.STRUCT:
5598 
          self.success = User()
5599 
          self.success.read(iprot)
94 ashish 5600 
        else:
5601 
          iprot.skip(ftype)
5602 
      elif fid == 1:
5603 
        if ftype == TType.STRUCT:
559 chandransh 5604 
          self.ucex = UserContextException()
5605 
          self.ucex.read(iprot)
94 ashish 5606 
        else:
5607 
          iprot.skip(ftype)
5608 
      else:
5609 
        iprot.skip(ftype)
5610 
      iprot.readFieldEnd()
5611 
    iprot.readStructEnd()
5612 
 
5613 
  def write(self, oprot):
5614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5616 
      return
5326 rajveer 5617 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5618 
    if self.success is not None:
5326 rajveer 5619 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5620 
      self.success.write(oprot)
94 ashish 5621 
      oprot.writeFieldEnd()
3431 rajveer 5622 
    if self.ucex is not None:
559 chandransh 5623 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5624 
      self.ucex.write(oprot)
94 ashish 5625 
      oprot.writeFieldEnd()
5626 
    oprot.writeFieldStop()
5627 
    oprot.writeStructEnd()
5628 
 
3431 rajveer 5629 
  def validate(self):
5630 
    return
5631 
 
5632 
 
94 ashish 5633 
  def __repr__(self):
5634 
    L = ['%s=%r' % (key, value)
5635 
      for key, value in self.__dict__.iteritems()]
5636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5637 
 
5638 
  def __eq__(self, other):
5639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5640 
 
5641 
  def __ne__(self, other):
5642 
    return not (self == other)
5643 
 
559 chandransh 5644 
class authenticateUser_args:
94 ashish 5645 
  """
5646 
  Attributes:
5647 
   - email
5648 
   - password
5649 
  """
5650 
 
5651 
  thrift_spec = (
5652 
    None, # 0
5653 
    (1, TType.STRING, 'email', None, None, ), # 1
5654 
    (2, TType.STRING, 'password', None, None, ), # 2
5655 
  )
5656 
 
5657 
  def __init__(self, email=None, password=None,):
5658 
    self.email = email
5659 
    self.password = password
5660 
 
5661 
  def read(self, iprot):
5662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5664 
      return
5665 
    iprot.readStructBegin()
5666 
    while True:
5667 
      (fname, ftype, fid) = iprot.readFieldBegin()
5668 
      if ftype == TType.STOP:
5669 
        break
5670 
      if fid == 1:
5671 
        if ftype == TType.STRING:
5672 
          self.email = iprot.readString();
5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      elif fid == 2:
5676 
        if ftype == TType.STRING:
5677 
          self.password = iprot.readString();
5678 
        else:
5679 
          iprot.skip(ftype)
5680 
      else:
5681 
        iprot.skip(ftype)
5682 
      iprot.readFieldEnd()
5683 
    iprot.readStructEnd()
5684 
 
5685 
  def write(self, oprot):
5686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5688 
      return
559 chandransh 5689 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5690 
    if self.email is not None:
94 ashish 5691 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5692 
      oprot.writeString(self.email)
5693 
      oprot.writeFieldEnd()
3431 rajveer 5694 
    if self.password is not None:
94 ashish 5695 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5696 
      oprot.writeString(self.password)
5697 
      oprot.writeFieldEnd()
5698 
    oprot.writeFieldStop()
5699 
    oprot.writeStructEnd()
5700 
 
3431 rajveer 5701 
  def validate(self):
5702 
    return
5703 
 
5704 
 
94 ashish 5705 
  def __repr__(self):
5706 
    L = ['%s=%r' % (key, value)
5707 
      for key, value in self.__dict__.iteritems()]
5708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5709 
 
5710 
  def __eq__(self, other):
5711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5712 
 
5713 
  def __ne__(self, other):
5714 
    return not (self == other)
5715 
 
559 chandransh 5716 
class authenticateUser_result:
94 ashish 5717 
  """
5718 
  Attributes:
5719 
   - success
559 chandransh 5720 
   - auex
94 ashish 5721 
  """
5722 
 
5723 
  thrift_spec = (
559 chandransh 5724 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5725 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5726 
  )
5727 
 
559 chandransh 5728 
  def __init__(self, success=None, auex=None,):
94 ashish 5729 
    self.success = success
559 chandransh 5730 
    self.auex = auex
94 ashish 5731 
 
5732 
  def read(self, iprot):
5733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5735 
      return
5736 
    iprot.readStructBegin()
5737 
    while True:
5738 
      (fname, ftype, fid) = iprot.readFieldBegin()
5739 
      if ftype == TType.STOP:
5740 
        break
5741 
      if fid == 0:
5742 
        if ftype == TType.STRUCT:
559 chandransh 5743 
          self.success = User()
94 ashish 5744 
          self.success.read(iprot)
5745 
        else:
5746 
          iprot.skip(ftype)
5747 
      elif fid == 1:
5748 
        if ftype == TType.STRUCT:
559 chandransh 5749 
          self.auex = AuthenticationException()
5750 
          self.auex.read(iprot)
94 ashish 5751 
        else:
5752 
          iprot.skip(ftype)
5753 
      else:
5754 
        iprot.skip(ftype)
5755 
      iprot.readFieldEnd()
5756 
    iprot.readStructEnd()
5757 
 
5758 
  def write(self, oprot):
5759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5761 
      return
559 chandransh 5762 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5763 
    if self.success is not None:
94 ashish 5764 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5765 
      self.success.write(oprot)
5766 
      oprot.writeFieldEnd()
3431 rajveer 5767 
    if self.auex is not None:
559 chandransh 5768 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5769 
      self.auex.write(oprot)
94 ashish 5770 
      oprot.writeFieldEnd()
5771 
    oprot.writeFieldStop()
5772 
    oprot.writeStructEnd()
5773 
 
3431 rajveer 5774 
  def validate(self):
5775 
    return
5776 
 
5777 
 
94 ashish 5778 
  def __repr__(self):
5779 
    L = ['%s=%r' % (key, value)
5780 
      for key, value in self.__dict__.iteritems()]
5781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5782 
 
5783 
  def __eq__(self, other):
5784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5785 
 
5786 
  def __ne__(self, other):
5787 
    return not (self == other)
5788 
 
559 chandransh 5789 
class userExists_args:
122 ashish 5790 
  """
5791 
  Attributes:
559 chandransh 5792 
   - email
122 ashish 5793 
  """
5794 
 
5795 
  thrift_spec = (
5796 
    None, # 0
559 chandransh 5797 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5798 
  )
5799 
 
559 chandransh 5800 
  def __init__(self, email=None,):
5801 
    self.email = email
122 ashish 5802 
 
5803 
  def read(self, iprot):
5804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5806 
      return
5807 
    iprot.readStructBegin()
5808 
    while True:
5809 
      (fname, ftype, fid) = iprot.readFieldBegin()
5810 
      if ftype == TType.STOP:
5811 
        break
5812 
      if fid == 1:
5813 
        if ftype == TType.STRING:
559 chandransh 5814 
          self.email = iprot.readString();
122 ashish 5815 
        else:
5816 
          iprot.skip(ftype)
559 chandransh 5817 
      else:
5818 
        iprot.skip(ftype)
5819 
      iprot.readFieldEnd()
5820 
    iprot.readStructEnd()
5821 
 
5822 
  def write(self, oprot):
5823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5825 
      return
5826 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5827 
    if self.email is not None:
559 chandransh 5828 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5829 
      oprot.writeString(self.email)
5830 
      oprot.writeFieldEnd()
5831 
    oprot.writeFieldStop()
5832 
    oprot.writeStructEnd()
5833 
 
3431 rajveer 5834 
  def validate(self):
5835 
    return
5836 
 
5837 
 
559 chandransh 5838 
  def __repr__(self):
5839 
    L = ['%s=%r' % (key, value)
5840 
      for key, value in self.__dict__.iteritems()]
5841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5842 
 
5843 
  def __eq__(self, other):
5844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5845 
 
5846 
  def __ne__(self, other):
5847 
    return not (self == other)
5848 
 
5849 
class userExists_result:
5850 
  """
5851 
  Attributes:
5852 
   - success
5853 
   - ucx
5854 
  """
5855 
 
5856 
  thrift_spec = (
5857 
    (0, TType.BOOL, 'success', None, None, ), # 0
5858 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5859 
  )
5860 
 
5861 
  def __init__(self, success=None, ucx=None,):
5862 
    self.success = success
5863 
    self.ucx = ucx
5864 
 
5865 
  def read(self, iprot):
5866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5868 
      return
5869 
    iprot.readStructBegin()
5870 
    while True:
5871 
      (fname, ftype, fid) = iprot.readFieldBegin()
5872 
      if ftype == TType.STOP:
5873 
        break
5874 
      if fid == 0:
5875 
        if ftype == TType.BOOL:
5876 
          self.success = iprot.readBool();
5877 
        else:
5878 
          iprot.skip(ftype)
5879 
      elif fid == 1:
5880 
        if ftype == TType.STRUCT:
5881 
          self.ucx = UserContextException()
5882 
          self.ucx.read(iprot)
5883 
        else:
5884 
          iprot.skip(ftype)
5885 
      else:
5886 
        iprot.skip(ftype)
5887 
      iprot.readFieldEnd()
5888 
    iprot.readStructEnd()
5889 
 
5890 
  def write(self, oprot):
5891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5893 
      return
5894 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 5895 
    if self.success is not None:
559 chandransh 5896 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5897 
      oprot.writeBool(self.success)
5898 
      oprot.writeFieldEnd()
3431 rajveer 5899 
    if self.ucx is not None:
559 chandransh 5900 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5901 
      self.ucx.write(oprot)
5902 
      oprot.writeFieldEnd()
5903 
    oprot.writeFieldStop()
5904 
    oprot.writeStructEnd()
5905 
 
3431 rajveer 5906 
  def validate(self):
5907 
    return
5908 
 
5909 
 
559 chandransh 5910 
  def __repr__(self):
5911 
    L = ['%s=%r' % (key, value)
5912 
      for key, value in self.__dict__.iteritems()]
5913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5914 
 
5915 
  def __eq__(self, other):
5916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5917 
 
5918 
  def __ne__(self, other):
5919 
    return not (self == other)
5920 
 
5921 
class addAddressForUser_args:
5922 
  """
5923 
  Attributes:
5924 
   - userId
5925 
   - address
5926 
   - setDefault
5927 
  """
5928 
 
5929 
  thrift_spec = (
5930 
    None, # 0
5931 
    (1, TType.I64, 'userId', None, None, ), # 1
5932 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5933 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5934 
  )
5935 
 
567 rajveer 5936 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5937 
    self.userId = userId
5938 
    self.address = address
5939 
    self.setDefault = setDefault
5940 
 
5941 
  def read(self, iprot):
5942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5944 
      return
5945 
    iprot.readStructBegin()
5946 
    while True:
5947 
      (fname, ftype, fid) = iprot.readFieldBegin()
5948 
      if ftype == TType.STOP:
5949 
        break
5950 
      if fid == 1:
5951 
        if ftype == TType.I64:
5952 
          self.userId = iprot.readI64();
5953 
        else:
5954 
          iprot.skip(ftype)
122 ashish 5955 
      elif fid == 2:
559 chandransh 5956 
        if ftype == TType.STRUCT:
5957 
          self.address = Address()
5958 
          self.address.read(iprot)
122 ashish 5959 
        else:
5960 
          iprot.skip(ftype)
5961 
      elif fid == 3:
5962 
        if ftype == TType.BOOL:
559 chandransh 5963 
          self.setDefault = iprot.readBool();
122 ashish 5964 
        else:
5965 
          iprot.skip(ftype)
5966 
      else:
5967 
        iprot.skip(ftype)
5968 
      iprot.readFieldEnd()
5969 
    iprot.readStructEnd()
5970 
 
5971 
  def write(self, oprot):
5972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5974 
      return
559 chandransh 5975 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 5976 
    if self.userId is not None:
559 chandransh 5977 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5978 
      oprot.writeI64(self.userId)
122 ashish 5979 
      oprot.writeFieldEnd()
3431 rajveer 5980 
    if self.address is not None:
559 chandransh 5981 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5982 
      self.address.write(oprot)
122 ashish 5983 
      oprot.writeFieldEnd()
3431 rajveer 5984 
    if self.setDefault is not None:
567 rajveer 5985 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5986 
      oprot.writeBool(self.setDefault)
5987 
      oprot.writeFieldEnd()
122 ashish 5988 
    oprot.writeFieldStop()
5989 
    oprot.writeStructEnd()
5990 
 
3431 rajveer 5991 
  def validate(self):
5992 
    return
5993 
 
5994 
 
122 ashish 5995 
  def __repr__(self):
5996 
    L = ['%s=%r' % (key, value)
5997 
      for key, value in self.__dict__.iteritems()]
5998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5999 
 
6000 
  def __eq__(self, other):
6001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6002 
 
6003 
  def __ne__(self, other):
6004 
    return not (self == other)
6005 
 
559 chandransh 6006 
class addAddressForUser_result:
122 ashish 6007 
  """
6008 
  Attributes:
6009 
   - success
559 chandransh 6010 
   - ucx
122 ashish 6011 
  """
6012 
 
6013 
  thrift_spec = (
567 rajveer 6014 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6015 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6016 
  )
6017 
 
559 chandransh 6018 
  def __init__(self, success=None, ucx=None,):
122 ashish 6019 
    self.success = success
559 chandransh 6020 
    self.ucx = ucx
122 ashish 6021 
 
6022 
  def read(self, iprot):
6023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6025 
      return
6026 
    iprot.readStructBegin()
6027 
    while True:
6028 
      (fname, ftype, fid) = iprot.readFieldBegin()
6029 
      if ftype == TType.STOP:
6030 
        break
6031 
      if fid == 0:
567 rajveer 6032 
        if ftype == TType.I64:
6033 
          self.success = iprot.readI64();
122 ashish 6034 
        else:
6035 
          iprot.skip(ftype)
6036 
      elif fid == 1:
6037 
        if ftype == TType.STRUCT:
559 chandransh 6038 
          self.ucx = UserContextException()
6039 
          self.ucx.read(iprot)
122 ashish 6040 
        else:
6041 
          iprot.skip(ftype)
6042 
      else:
6043 
        iprot.skip(ftype)
6044 
      iprot.readFieldEnd()
6045 
    iprot.readStructEnd()
6046 
 
6047 
  def write(self, oprot):
6048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6050 
      return
559 chandransh 6051 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6052 
    if self.success is not None:
567 rajveer 6053 
      oprot.writeFieldBegin('success', TType.I64, 0)
6054 
      oprot.writeI64(self.success)
122 ashish 6055 
      oprot.writeFieldEnd()
3431 rajveer 6056 
    if self.ucx is not None:
559 chandransh 6057 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6058 
      self.ucx.write(oprot)
122 ashish 6059 
      oprot.writeFieldEnd()
6060 
    oprot.writeFieldStop()
6061 
    oprot.writeStructEnd()
6062 
 
3431 rajveer 6063 
  def validate(self):
6064 
    return
6065 
 
6066 
 
122 ashish 6067 
  def __repr__(self):
6068 
    L = ['%s=%r' % (key, value)
6069 
      for key, value in self.__dict__.iteritems()]
6070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6071 
 
6072 
  def __eq__(self, other):
6073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6074 
 
6075 
  def __ne__(self, other):
6076 
    return not (self == other)
6077 
 
559 chandransh 6078 
class removeAddressForUser_args:
94 ashish 6079 
  """
6080 
  Attributes:
559 chandransh 6081 
   - userid
6082 
   - addressId
94 ashish 6083 
  """
6084 
 
6085 
  thrift_spec = (
6086 
    None, # 0
559 chandransh 6087 
    (1, TType.I64, 'userid', None, None, ), # 1
6088 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6089 
  )
6090 
 
559 chandransh 6091 
  def __init__(self, userid=None, addressId=None,):
6092 
    self.userid = userid
6093 
    self.addressId = addressId
94 ashish 6094 
 
6095 
  def read(self, iprot):
6096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6098 
      return
6099 
    iprot.readStructBegin()
6100 
    while True:
6101 
      (fname, ftype, fid) = iprot.readFieldBegin()
6102 
      if ftype == TType.STOP:
6103 
        break
6104 
      if fid == 1:
559 chandransh 6105 
        if ftype == TType.I64:
6106 
          self.userid = iprot.readI64();
94 ashish 6107 
        else:
6108 
          iprot.skip(ftype)
559 chandransh 6109 
      elif fid == 2:
6110 
        if ftype == TType.I64:
6111 
          self.addressId = iprot.readI64();
6112 
        else:
6113 
          iprot.skip(ftype)
94 ashish 6114 
      else:
6115 
        iprot.skip(ftype)
6116 
      iprot.readFieldEnd()
6117 
    iprot.readStructEnd()
6118 
 
6119 
  def write(self, oprot):
6120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6122 
      return
559 chandransh 6123 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6124 
    if self.userid is not None:
559 chandransh 6125 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6126 
      oprot.writeI64(self.userid)
94 ashish 6127 
      oprot.writeFieldEnd()
3431 rajveer 6128 
    if self.addressId is not None:
559 chandransh 6129 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6130 
      oprot.writeI64(self.addressId)
6131 
      oprot.writeFieldEnd()
94 ashish 6132 
    oprot.writeFieldStop()
6133 
    oprot.writeStructEnd()
6134 
 
3431 rajveer 6135 
  def validate(self):
6136 
    return
6137 
 
6138 
 
94 ashish 6139 
  def __repr__(self):
6140 
    L = ['%s=%r' % (key, value)
6141 
      for key, value in self.__dict__.iteritems()]
6142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6143 
 
6144 
  def __eq__(self, other):
6145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6146 
 
6147 
  def __ne__(self, other):
6148 
    return not (self == other)
6149 
 
559 chandransh 6150 
class removeAddressForUser_result:
94 ashish 6151 
  """
6152 
  Attributes:
6153 
   - success
6154 
   - ucx
6155 
  """
6156 
 
6157 
  thrift_spec = (
6158 
    (0, TType.BOOL, 'success', None, None, ), # 0
6159 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6160 
  )
6161 
 
6162 
  def __init__(self, success=None, ucx=None,):
6163 
    self.success = success
6164 
    self.ucx = ucx
6165 
 
6166 
  def read(self, iprot):
6167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6169 
      return
6170 
    iprot.readStructBegin()
6171 
    while True:
6172 
      (fname, ftype, fid) = iprot.readFieldBegin()
6173 
      if ftype == TType.STOP:
6174 
        break
6175 
      if fid == 0:
6176 
        if ftype == TType.BOOL:
6177 
          self.success = iprot.readBool();
6178 
        else:
6179 
          iprot.skip(ftype)
6180 
      elif fid == 1:
6181 
        if ftype == TType.STRUCT:
6182 
          self.ucx = UserContextException()
6183 
          self.ucx.read(iprot)
6184 
        else:
6185 
          iprot.skip(ftype)
6186 
      else:
6187 
        iprot.skip(ftype)
6188 
      iprot.readFieldEnd()
6189 
    iprot.readStructEnd()
6190 
 
6191 
  def write(self, oprot):
6192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6194 
      return
559 chandransh 6195 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6196 
    if self.success is not None:
94 ashish 6197 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6198 
      oprot.writeBool(self.success)
6199 
      oprot.writeFieldEnd()
3431 rajveer 6200 
    if self.ucx is not None:
94 ashish 6201 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6202 
      self.ucx.write(oprot)
6203 
      oprot.writeFieldEnd()
6204 
    oprot.writeFieldStop()
6205 
    oprot.writeStructEnd()
6206 
 
3431 rajveer 6207 
  def validate(self):
6208 
    return
6209 
 
6210 
 
94 ashish 6211 
  def __repr__(self):
6212 
    L = ['%s=%r' % (key, value)
6213 
      for key, value in self.__dict__.iteritems()]
6214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6215 
 
6216 
  def __eq__(self, other):
6217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6218 
 
6219 
  def __ne__(self, other):
6220 
    return not (self == other)
6221 
 
559 chandransh 6222 
class setUserAsLoggedIn_args:
94 ashish 6223 
  """
6224 
  Attributes:
559 chandransh 6225 
   - userId
94 ashish 6226 
   - timestamp
6227 
  """
6228 
 
6229 
  thrift_spec = (
6230 
    None, # 0
559 chandransh 6231 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6232 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6233 
  )
6234 
 
559 chandransh 6235 
  def __init__(self, userId=None, timestamp=None,):
6236 
    self.userId = userId
94 ashish 6237 
    self.timestamp = timestamp
6238 
 
6239 
  def read(self, iprot):
6240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6242 
      return
6243 
    iprot.readStructBegin()
6244 
    while True:
6245 
      (fname, ftype, fid) = iprot.readFieldBegin()
6246 
      if ftype == TType.STOP:
6247 
        break
6248 
      if fid == 1:
559 chandransh 6249 
        if ftype == TType.I64:
6250 
          self.userId = iprot.readI64();
94 ashish 6251 
        else:
6252 
          iprot.skip(ftype)
6253 
      elif fid == 2:
6254 
        if ftype == TType.I64:
6255 
          self.timestamp = iprot.readI64();
6256 
        else:
6257 
          iprot.skip(ftype)
6258 
      else:
6259 
        iprot.skip(ftype)
6260 
      iprot.readFieldEnd()
6261 
    iprot.readStructEnd()
6262 
 
6263 
  def write(self, oprot):
6264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6266 
      return
559 chandransh 6267 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6268 
    if self.userId is not None:
559 chandransh 6269 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6270 
      oprot.writeI64(self.userId)
94 ashish 6271 
      oprot.writeFieldEnd()
3431 rajveer 6272 
    if self.timestamp is not None:
94 ashish 6273 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6274 
      oprot.writeI64(self.timestamp)
6275 
      oprot.writeFieldEnd()
6276 
    oprot.writeFieldStop()
6277 
    oprot.writeStructEnd()
6278 
 
3431 rajveer 6279 
  def validate(self):
6280 
    return
6281 
 
6282 
 
94 ashish 6283 
  def __repr__(self):
6284 
    L = ['%s=%r' % (key, value)
6285 
      for key, value in self.__dict__.iteritems()]
6286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6287 
 
6288 
  def __eq__(self, other):
6289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6290 
 
6291 
  def __ne__(self, other):
6292 
    return not (self == other)
6293 
 
559 chandransh 6294 
class setUserAsLoggedIn_result:
94 ashish 6295 
  """
6296 
  Attributes:
6297 
   - success
6298 
   - ucx
6299 
  """
6300 
 
6301 
  thrift_spec = (
6302 
    (0, TType.BOOL, 'success', None, None, ), # 0
6303 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6304 
  )
6305 
 
6306 
  def __init__(self, success=None, ucx=None,):
6307 
    self.success = success
6308 
    self.ucx = ucx
6309 
 
6310 
  def read(self, iprot):
6311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6313 
      return
6314 
    iprot.readStructBegin()
6315 
    while True:
6316 
      (fname, ftype, fid) = iprot.readFieldBegin()
6317 
      if ftype == TType.STOP:
6318 
        break
6319 
      if fid == 0:
6320 
        if ftype == TType.BOOL:
6321 
          self.success = iprot.readBool();
6322 
        else:
6323 
          iprot.skip(ftype)
6324 
      elif fid == 1:
6325 
        if ftype == TType.STRUCT:
6326 
          self.ucx = UserContextException()
6327 
          self.ucx.read(iprot)
6328 
        else:
6329 
          iprot.skip(ftype)
6330 
      else:
6331 
        iprot.skip(ftype)
6332 
      iprot.readFieldEnd()
6333 
    iprot.readStructEnd()
6334 
 
6335 
  def write(self, oprot):
6336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6338 
      return
559 chandransh 6339 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6340 
    if self.success is not None:
94 ashish 6341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6342 
      oprot.writeBool(self.success)
6343 
      oprot.writeFieldEnd()
3431 rajveer 6344 
    if self.ucx is not None:
94 ashish 6345 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6346 
      self.ucx.write(oprot)
6347 
      oprot.writeFieldEnd()
6348 
    oprot.writeFieldStop()
6349 
    oprot.writeStructEnd()
6350 
 
3431 rajveer 6351 
  def validate(self):
6352 
    return
6353 
 
6354 
 
94 ashish 6355 
  def __repr__(self):
6356 
    L = ['%s=%r' % (key, value)
6357 
      for key, value in self.__dict__.iteritems()]
6358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6359 
 
6360 
  def __eq__(self, other):
6361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6362 
 
6363 
  def __ne__(self, other):
6364 
    return not (self == other)
6365 
 
559 chandransh 6366 
class setUserAsLoggedOut_args:
94 ashish 6367 
  """
6368 
  Attributes:
6369 
   - userid
6370 
   - timestamp
6371 
  """
6372 
 
6373 
  thrift_spec = (
6374 
    None, # 0
559 chandransh 6375 
    (1, TType.I64, 'userid', None, None, ), # 1
6376 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6377 
  )
6378 
 
559 chandransh 6379 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6380 
    self.userid = userid
6381 
    self.timestamp = timestamp
6382 
 
6383 
  def read(self, iprot):
6384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6386 
      return
6387 
    iprot.readStructBegin()
6388 
    while True:
6389 
      (fname, ftype, fid) = iprot.readFieldBegin()
6390 
      if ftype == TType.STOP:
6391 
        break
6392 
      if fid == 1:
6393 
        if ftype == TType.I64:
6394 
          self.userid = iprot.readI64();
6395 
        else:
6396 
          iprot.skip(ftype)
559 chandransh 6397 
      elif fid == 2:
94 ashish 6398 
        if ftype == TType.I64:
6399 
          self.timestamp = iprot.readI64();
6400 
        else:
6401 
          iprot.skip(ftype)
6402 
      else:
6403 
        iprot.skip(ftype)
6404 
      iprot.readFieldEnd()
6405 
    iprot.readStructEnd()
6406 
 
6407 
  def write(self, oprot):
6408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6410 
      return
559 chandransh 6411 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6412 
    if self.userid is not None:
559 chandransh 6413 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6414 
      oprot.writeI64(self.userid)
6415 
      oprot.writeFieldEnd()
3431 rajveer 6416 
    if self.timestamp is not None:
559 chandransh 6417 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6418 
      oprot.writeI64(self.timestamp)
6419 
      oprot.writeFieldEnd()
6420 
    oprot.writeFieldStop()
6421 
    oprot.writeStructEnd()
6422 
 
3431 rajveer 6423 
  def validate(self):
6424 
    return
6425 
 
6426 
 
94 ashish 6427 
  def __repr__(self):
6428 
    L = ['%s=%r' % (key, value)
6429 
      for key, value in self.__dict__.iteritems()]
6430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6431 
 
6432 
  def __eq__(self, other):
6433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6434 
 
6435 
  def __ne__(self, other):
6436 
    return not (self == other)
6437 
 
559 chandransh 6438 
class setUserAsLoggedOut_result:
94 ashish 6439 
  """
6440 
  Attributes:
6441 
   - success
6442 
   - ucx
6443 
  """
6444 
 
6445 
  thrift_spec = (
6446 
    (0, TType.BOOL, 'success', None, None, ), # 0
6447 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6448 
  )
6449 
 
6450 
  def __init__(self, success=None, ucx=None,):
6451 
    self.success = success
6452 
    self.ucx = ucx
6453 
 
6454 
  def read(self, iprot):
6455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6457 
      return
6458 
    iprot.readStructBegin()
6459 
    while True:
6460 
      (fname, ftype, fid) = iprot.readFieldBegin()
6461 
      if ftype == TType.STOP:
6462 
        break
6463 
      if fid == 0:
6464 
        if ftype == TType.BOOL:
6465 
          self.success = iprot.readBool();
6466 
        else:
6467 
          iprot.skip(ftype)
6468 
      elif fid == 1:
6469 
        if ftype == TType.STRUCT:
6470 
          self.ucx = UserContextException()
6471 
          self.ucx.read(iprot)
6472 
        else:
6473 
          iprot.skip(ftype)
6474 
      else:
6475 
        iprot.skip(ftype)
6476 
      iprot.readFieldEnd()
6477 
    iprot.readStructEnd()
6478 
 
6479 
  def write(self, oprot):
6480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6482 
      return
559 chandransh 6483 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6484 
    if self.success is not None:
94 ashish 6485 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6486 
      oprot.writeBool(self.success)
6487 
      oprot.writeFieldEnd()
3431 rajveer 6488 
    if self.ucx is not None:
94 ashish 6489 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6490 
      self.ucx.write(oprot)
6491 
      oprot.writeFieldEnd()
6492 
    oprot.writeFieldStop()
6493 
    oprot.writeStructEnd()
6494 
 
3431 rajveer 6495 
  def validate(self):
6496 
    return
6497 
 
6498 
 
94 ashish 6499 
  def __repr__(self):
6500 
    L = ['%s=%r' % (key, value)
6501 
      for key, value in self.__dict__.iteritems()]
6502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6503 
 
6504 
  def __eq__(self, other):
6505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6506 
 
6507 
  def __ne__(self, other):
6508 
    return not (self == other)
6509 
 
559 chandransh 6510 
class setDefaultAddress_args:
94 ashish 6511 
  """
6512 
  Attributes:
6513 
   - userid
6514 
   - addressId
6515 
  """
6516 
 
6517 
  thrift_spec = (
6518 
    None, # 0
6519 
    (1, TType.I64, 'userid', None, None, ), # 1
6520 
    (2, TType.I64, 'addressId', None, None, ), # 2
6521 
  )
6522 
 
6523 
  def __init__(self, userid=None, addressId=None,):
6524 
    self.userid = userid
6525 
    self.addressId = addressId
6526 
 
6527 
  def read(self, iprot):
6528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6530 
      return
6531 
    iprot.readStructBegin()
6532 
    while True:
6533 
      (fname, ftype, fid) = iprot.readFieldBegin()
6534 
      if ftype == TType.STOP:
6535 
        break
6536 
      if fid == 1:
6537 
        if ftype == TType.I64:
6538 
          self.userid = iprot.readI64();
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      elif fid == 2:
6542 
        if ftype == TType.I64:
6543 
          self.addressId = iprot.readI64();
6544 
        else:
6545 
          iprot.skip(ftype)
6546 
      else:
6547 
        iprot.skip(ftype)
6548 
      iprot.readFieldEnd()
6549 
    iprot.readStructEnd()
6550 
 
6551 
  def write(self, oprot):
6552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6554 
      return
559 chandransh 6555 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6556 
    if self.userid is not None:
94 ashish 6557 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6558 
      oprot.writeI64(self.userid)
6559 
      oprot.writeFieldEnd()
3431 rajveer 6560 
    if self.addressId is not None:
94 ashish 6561 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6562 
      oprot.writeI64(self.addressId)
6563 
      oprot.writeFieldEnd()
6564 
    oprot.writeFieldStop()
6565 
    oprot.writeStructEnd()
6566 
 
3431 rajveer 6567 
  def validate(self):
6568 
    return
6569 
 
6570 
 
94 ashish 6571 
  def __repr__(self):
6572 
    L = ['%s=%r' % (key, value)
6573 
      for key, value in self.__dict__.iteritems()]
6574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6575 
 
6576 
  def __eq__(self, other):
6577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6578 
 
6579 
  def __ne__(self, other):
6580 
    return not (self == other)
6581 
 
559 chandransh 6582 
class setDefaultAddress_result:
94 ashish 6583 
  """
6584 
  Attributes:
6585 
   - success
6586 
   - ucx
6587 
  """
6588 
 
6589 
  thrift_spec = (
6590 
    (0, TType.BOOL, 'success', None, None, ), # 0
6591 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6592 
  )
6593 
 
6594 
  def __init__(self, success=None, ucx=None,):
6595 
    self.success = success
6596 
    self.ucx = ucx
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 == 0:
6608 
        if ftype == TType.BOOL:
6609 
          self.success = iprot.readBool();
6610 
        else:
6611 
          iprot.skip(ftype)
6612 
      elif fid == 1:
6613 
        if ftype == TType.STRUCT:
6614 
          self.ucx = UserContextException()
6615 
          self.ucx.read(iprot)
6616 
        else:
6617 
          iprot.skip(ftype)
6618 
      else:
6619 
        iprot.skip(ftype)
6620 
      iprot.readFieldEnd()
6621 
    iprot.readStructEnd()
6622 
 
6623 
  def write(self, oprot):
6624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6626 
      return
559 chandransh 6627 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6628 
    if self.success is not None:
94 ashish 6629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6630 
      oprot.writeBool(self.success)
6631 
      oprot.writeFieldEnd()
3431 rajveer 6632 
    if self.ucx is not None:
94 ashish 6633 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6634 
      self.ucx.write(oprot)
6635 
      oprot.writeFieldEnd()
6636 
    oprot.writeFieldStop()
6637 
    oprot.writeStructEnd()
6638 
 
3431 rajveer 6639 
  def validate(self):
6640 
    return
6641 
 
6642 
 
94 ashish 6643 
  def __repr__(self):
6644 
    L = ['%s=%r' % (key, value)
6645 
      for key, value in self.__dict__.iteritems()]
6646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6647 
 
6648 
  def __eq__(self, other):
6649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6650 
 
6651 
  def __ne__(self, other):
6652 
    return not (self == other)
6653 
 
559 chandransh 6654 
class updatePassword_args:
94 ashish 6655 
  """
6656 
  Attributes:
559 chandransh 6657 
   - userid
594 rajveer 6658 
   - oldPassword
6659 
   - newPassword
94 ashish 6660 
  """
6661 
 
6662 
  thrift_spec = (
6663 
    None, # 0
559 chandransh 6664 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6665 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6666 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6667 
  )
6668 
 
594 rajveer 6669 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6670 
    self.userid = userid
594 rajveer 6671 
    self.oldPassword = oldPassword
6672 
    self.newPassword = newPassword
94 ashish 6673 
 
6674 
  def read(self, iprot):
6675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6677 
      return
6678 
    iprot.readStructBegin()
6679 
    while True:
6680 
      (fname, ftype, fid) = iprot.readFieldBegin()
6681 
      if ftype == TType.STOP:
6682 
        break
6683 
      if fid == 1:
6684 
        if ftype == TType.I64:
559 chandransh 6685 
          self.userid = iprot.readI64();
94 ashish 6686 
        else:
6687 
          iprot.skip(ftype)
6688 
      elif fid == 2:
559 chandransh 6689 
        if ftype == TType.STRING:
594 rajveer 6690 
          self.oldPassword = iprot.readString();
94 ashish 6691 
        else:
6692 
          iprot.skip(ftype)
594 rajveer 6693 
      elif fid == 3:
6694 
        if ftype == TType.STRING:
6695 
          self.newPassword = iprot.readString();
6696 
        else:
6697 
          iprot.skip(ftype)
94 ashish 6698 
      else:
6699 
        iprot.skip(ftype)
6700 
      iprot.readFieldEnd()
6701 
    iprot.readStructEnd()
6702 
 
6703 
  def write(self, oprot):
6704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6706 
      return
559 chandransh 6707 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6708 
    if self.userid is not None:
559 chandransh 6709 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6710 
      oprot.writeI64(self.userid)
94 ashish 6711 
      oprot.writeFieldEnd()
3431 rajveer 6712 
    if self.oldPassword is not None:
594 rajveer 6713 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6714 
      oprot.writeString(self.oldPassword)
94 ashish 6715 
      oprot.writeFieldEnd()
3431 rajveer 6716 
    if self.newPassword is not None:
594 rajveer 6717 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6718 
      oprot.writeString(self.newPassword)
6719 
      oprot.writeFieldEnd()
94 ashish 6720 
    oprot.writeFieldStop()
6721 
    oprot.writeStructEnd()
6722 
 
3431 rajveer 6723 
  def validate(self):
6724 
    return
6725 
 
6726 
 
94 ashish 6727 
  def __repr__(self):
6728 
    L = ['%s=%r' % (key, value)
6729 
      for key, value in self.__dict__.iteritems()]
6730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6731 
 
6732 
  def __eq__(self, other):
6733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6734 
 
6735 
  def __ne__(self, other):
6736 
    return not (self == other)
6737 
 
559 chandransh 6738 
class updatePassword_result:
94 ashish 6739 
  """
6740 
  Attributes:
6741 
   - success
6742 
   - ucx
6743 
  """
6744 
 
6745 
  thrift_spec = (
6746 
    (0, TType.BOOL, 'success', None, None, ), # 0
6747 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6748 
  )
6749 
 
6750 
  def __init__(self, success=None, ucx=None,):
6751 
    self.success = success
6752 
    self.ucx = ucx
6753 
 
6754 
  def read(self, iprot):
6755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6757 
      return
6758 
    iprot.readStructBegin()
6759 
    while True:
6760 
      (fname, ftype, fid) = iprot.readFieldBegin()
6761 
      if ftype == TType.STOP:
6762 
        break
6763 
      if fid == 0:
6764 
        if ftype == TType.BOOL:
6765 
          self.success = iprot.readBool();
6766 
        else:
6767 
          iprot.skip(ftype)
6768 
      elif fid == 1:
6769 
        if ftype == TType.STRUCT:
6770 
          self.ucx = UserContextException()
6771 
          self.ucx.read(iprot)
6772 
        else:
6773 
          iprot.skip(ftype)
6774 
      else:
6775 
        iprot.skip(ftype)
6776 
      iprot.readFieldEnd()
6777 
    iprot.readStructEnd()
6778 
 
6779 
  def write(self, oprot):
6780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6782 
      return
559 chandransh 6783 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6784 
    if self.success is not None:
94 ashish 6785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6786 
      oprot.writeBool(self.success)
6787 
      oprot.writeFieldEnd()
3431 rajveer 6788 
    if self.ucx is not None:
94 ashish 6789 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6790 
      self.ucx.write(oprot)
6791 
      oprot.writeFieldEnd()
6792 
    oprot.writeFieldStop()
6793 
    oprot.writeStructEnd()
6794 
 
3431 rajveer 6795 
  def validate(self):
6796 
    return
6797 
 
6798 
 
94 ashish 6799 
  def __repr__(self):
6800 
    L = ['%s=%r' % (key, value)
6801 
      for key, value in self.__dict__.iteritems()]
6802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6803 
 
6804 
  def __eq__(self, other):
6805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6806 
 
6807 
  def __ne__(self, other):
6808 
    return not (self == other)
6809 
 
581 rajveer 6810 
class forgotPassword_args:
6811 
  """
6812 
  Attributes:
6813 
   - email
884 rajveer 6814 
   - newPassword
581 rajveer 6815 
  """
6816 
 
6817 
  thrift_spec = (
6818 
    None, # 0
6819 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6820 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6821 
  )
6822 
 
884 rajveer 6823 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6824 
    self.email = email
884 rajveer 6825 
    self.newPassword = newPassword
581 rajveer 6826 
 
6827 
  def read(self, iprot):
6828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6830 
      return
6831 
    iprot.readStructBegin()
6832 
    while True:
6833 
      (fname, ftype, fid) = iprot.readFieldBegin()
6834 
      if ftype == TType.STOP:
6835 
        break
6836 
      if fid == 1:
6837 
        if ftype == TType.STRING:
6838 
          self.email = iprot.readString();
6839 
        else:
6840 
          iprot.skip(ftype)
884 rajveer 6841 
      elif fid == 2:
6842 
        if ftype == TType.STRING:
6843 
          self.newPassword = iprot.readString();
6844 
        else:
6845 
          iprot.skip(ftype)
581 rajveer 6846 
      else:
6847 
        iprot.skip(ftype)
6848 
      iprot.readFieldEnd()
6849 
    iprot.readStructEnd()
6850 
 
6851 
  def write(self, oprot):
6852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6854 
      return
6855 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6856 
    if self.email is not None:
581 rajveer 6857 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6858 
      oprot.writeString(self.email)
6859 
      oprot.writeFieldEnd()
3431 rajveer 6860 
    if self.newPassword is not None:
884 rajveer 6861 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6862 
      oprot.writeString(self.newPassword)
6863 
      oprot.writeFieldEnd()
581 rajveer 6864 
    oprot.writeFieldStop()
6865 
    oprot.writeStructEnd()
6866 
 
3431 rajveer 6867 
  def validate(self):
6868 
    return
6869 
 
6870 
 
581 rajveer 6871 
  def __repr__(self):
6872 
    L = ['%s=%r' % (key, value)
6873 
      for key, value in self.__dict__.iteritems()]
6874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6875 
 
6876 
  def __eq__(self, other):
6877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6878 
 
6879 
  def __ne__(self, other):
6880 
    return not (self == other)
6881 
 
6882 
class forgotPassword_result:
6883 
  """
6884 
  Attributes:
6885 
   - success
6886 
   - ucx
6887 
  """
6888 
 
6889 
  thrift_spec = (
6890 
    (0, TType.BOOL, 'success', None, None, ), # 0
6891 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6892 
  )
6893 
 
6894 
  def __init__(self, success=None, ucx=None,):
6895 
    self.success = success
6896 
    self.ucx = ucx
6897 
 
6898 
  def read(self, iprot):
6899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6901 
      return
6902 
    iprot.readStructBegin()
6903 
    while True:
6904 
      (fname, ftype, fid) = iprot.readFieldBegin()
6905 
      if ftype == TType.STOP:
6906 
        break
6907 
      if fid == 0:
6908 
        if ftype == TType.BOOL:
6909 
          self.success = iprot.readBool();
6910 
        else:
6911 
          iprot.skip(ftype)
6912 
      elif fid == 1:
6913 
        if ftype == TType.STRUCT:
6914 
          self.ucx = UserContextException()
6915 
          self.ucx.read(iprot)
6916 
        else:
6917 
          iprot.skip(ftype)
6918 
      else:
6919 
        iprot.skip(ftype)
6920 
      iprot.readFieldEnd()
6921 
    iprot.readStructEnd()
6922 
 
6923 
  def write(self, oprot):
6924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6926 
      return
6927 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 6928 
    if self.success is not None:
581 rajveer 6929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6930 
      oprot.writeBool(self.success)
6931 
      oprot.writeFieldEnd()
3431 rajveer 6932 
    if self.ucx is not None:
581 rajveer 6933 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6934 
      self.ucx.write(oprot)
6935 
      oprot.writeFieldEnd()
6936 
    oprot.writeFieldStop()
6937 
    oprot.writeStructEnd()
6938 
 
3431 rajveer 6939 
  def validate(self):
6940 
    return
6941 
 
6942 
 
581 rajveer 6943 
  def __repr__(self):
6944 
    L = ['%s=%r' % (key, value)
6945 
      for key, value in self.__dict__.iteritems()]
6946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6947 
 
6948 
  def __eq__(self, other):
6949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6950 
 
6951 
  def __ne__(self, other):
6952 
    return not (self == other)
6953 
 
594 rajveer 6954 
class getAllAddressesForUser_args:
6955 
  """
6956 
  Attributes:
6957 
   - userId
6958 
  """
6959 
 
6960 
  thrift_spec = (
6961 
    None, # 0
6962 
    (1, TType.I64, 'userId', None, None, ), # 1
6963 
  )
6964 
 
6965 
  def __init__(self, userId=None,):
6966 
    self.userId = userId
6967 
 
6968 
  def read(self, iprot):
6969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6971 
      return
6972 
    iprot.readStructBegin()
6973 
    while True:
6974 
      (fname, ftype, fid) = iprot.readFieldBegin()
6975 
      if ftype == TType.STOP:
6976 
        break
6977 
      if fid == 1:
6978 
        if ftype == TType.I64:
6979 
          self.userId = iprot.readI64();
6980 
        else:
6981 
          iprot.skip(ftype)
6982 
      else:
6983 
        iprot.skip(ftype)
6984 
      iprot.readFieldEnd()
6985 
    iprot.readStructEnd()
6986 
 
6987 
  def write(self, oprot):
6988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6990 
      return
6991 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 6992 
    if self.userId is not None:
594 rajveer 6993 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6994 
      oprot.writeI64(self.userId)
6995 
      oprot.writeFieldEnd()
6996 
    oprot.writeFieldStop()
6997 
    oprot.writeStructEnd()
6998 
 
3431 rajveer 6999 
  def validate(self):
7000 
    return
7001 
 
7002 
 
594 rajveer 7003 
  def __repr__(self):
7004 
    L = ['%s=%r' % (key, value)
7005 
      for key, value in self.__dict__.iteritems()]
7006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7007 
 
7008 
  def __eq__(self, other):
7009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7010 
 
7011 
  def __ne__(self, other):
7012 
    return not (self == other)
7013 
 
7014 
class getAllAddressesForUser_result:
7015 
  """
7016 
  Attributes:
7017 
   - success
7018 
   - ucx
7019 
  """
7020 
 
7021 
  thrift_spec = (
7022 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7023 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7024 
  )
7025 
 
7026 
  def __init__(self, success=None, ucx=None,):
7027 
    self.success = success
7028 
    self.ucx = ucx
7029 
 
7030 
  def read(self, iprot):
7031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7033 
      return
7034 
    iprot.readStructBegin()
7035 
    while True:
7036 
      (fname, ftype, fid) = iprot.readFieldBegin()
7037 
      if ftype == TType.STOP:
7038 
        break
7039 
      if fid == 0:
7040 
        if ftype == TType.LIST:
7041 
          self.success = []
11592 amit.gupta 7042 
          (_etype100, _size97) = iprot.readListBegin()
7043 
          for _i101 in xrange(_size97):
7044 
            _elem102 = Address()
7045 
            _elem102.read(iprot)
7046 
            self.success.append(_elem102)
594 rajveer 7047 
          iprot.readListEnd()
7048 
        else:
7049 
          iprot.skip(ftype)
7050 
      elif fid == 1:
7051 
        if ftype == TType.STRUCT:
7052 
          self.ucx = UserContextException()
7053 
          self.ucx.read(iprot)
7054 
        else:
7055 
          iprot.skip(ftype)
7056 
      else:
7057 
        iprot.skip(ftype)
7058 
      iprot.readFieldEnd()
7059 
    iprot.readStructEnd()
7060 
 
7061 
  def write(self, oprot):
7062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7064 
      return
7065 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7066 
    if self.success is not None:
594 rajveer 7067 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7068 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7069 
      for iter103 in self.success:
7070 
        iter103.write(oprot)
594 rajveer 7071 
      oprot.writeListEnd()
7072 
      oprot.writeFieldEnd()
3431 rajveer 7073 
    if self.ucx is not None:
594 rajveer 7074 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7075 
      self.ucx.write(oprot)
7076 
      oprot.writeFieldEnd()
7077 
    oprot.writeFieldStop()
7078 
    oprot.writeStructEnd()
7079 
 
3431 rajveer 7080 
  def validate(self):
7081 
    return
7082 
 
7083 
 
594 rajveer 7084 
  def __repr__(self):
7085 
    L = ['%s=%r' % (key, value)
7086 
      for key, value in self.__dict__.iteritems()]
7087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7088 
 
7089 
  def __eq__(self, other):
7090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7091 
 
7092 
  def __ne__(self, other):
7093 
    return not (self == other)
7094 
 
1894 vikas 7095 
class getAddressById_args:
7096 
  """
7097 
  Attributes:
7098 
   - addressId
7099 
  """
7100 
 
7101 
  thrift_spec = (
7102 
    None, # 0
7103 
    (1, TType.I64, 'addressId', None, None, ), # 1
7104 
  )
7105 
 
7106 
  def __init__(self, addressId=None,):
7107 
    self.addressId = addressId
7108 
 
7109 
  def read(self, iprot):
7110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7112 
      return
7113 
    iprot.readStructBegin()
7114 
    while True:
7115 
      (fname, ftype, fid) = iprot.readFieldBegin()
7116 
      if ftype == TType.STOP:
7117 
        break
7118 
      if fid == 1:
7119 
        if ftype == TType.I64:
7120 
          self.addressId = iprot.readI64();
7121 
        else:
7122 
          iprot.skip(ftype)
7123 
      else:
7124 
        iprot.skip(ftype)
7125 
      iprot.readFieldEnd()
7126 
    iprot.readStructEnd()
7127 
 
7128 
  def write(self, oprot):
7129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7131 
      return
7132 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7133 
    if self.addressId is not None:
1894 vikas 7134 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7135 
      oprot.writeI64(self.addressId)
7136 
      oprot.writeFieldEnd()
7137 
    oprot.writeFieldStop()
7138 
    oprot.writeStructEnd()
7139 
 
3431 rajveer 7140 
  def validate(self):
7141 
    return
7142 
 
7143 
 
1894 vikas 7144 
  def __repr__(self):
7145 
    L = ['%s=%r' % (key, value)
7146 
      for key, value in self.__dict__.iteritems()]
7147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7148 
 
7149 
  def __eq__(self, other):
7150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7151 
 
7152 
  def __ne__(self, other):
7153 
    return not (self == other)
7154 
 
7155 
class getAddressById_result:
7156 
  """
7157 
  Attributes:
7158 
   - success
7159 
   - ucx
7160 
  """
7161 
 
7162 
  thrift_spec = (
7163 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7164 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7165 
  )
7166 
 
7167 
  def __init__(self, success=None, ucx=None,):
7168 
    self.success = success
7169 
    self.ucx = ucx
7170 
 
7171 
  def read(self, iprot):
7172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7174 
      return
7175 
    iprot.readStructBegin()
7176 
    while True:
7177 
      (fname, ftype, fid) = iprot.readFieldBegin()
7178 
      if ftype == TType.STOP:
7179 
        break
7180 
      if fid == 0:
7181 
        if ftype == TType.STRUCT:
7182 
          self.success = Address()
7183 
          self.success.read(iprot)
7184 
        else:
7185 
          iprot.skip(ftype)
7186 
      elif fid == 1:
7187 
        if ftype == TType.STRUCT:
7188 
          self.ucx = UserContextException()
7189 
          self.ucx.read(iprot)
7190 
        else:
7191 
          iprot.skip(ftype)
7192 
      else:
7193 
        iprot.skip(ftype)
7194 
      iprot.readFieldEnd()
7195 
    iprot.readStructEnd()
7196 
 
7197 
  def write(self, oprot):
7198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7200 
      return
7201 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7202 
    if self.success is not None:
1894 vikas 7203 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7204 
      self.success.write(oprot)
7205 
      oprot.writeFieldEnd()
3431 rajveer 7206 
    if self.ucx is not None:
1894 vikas 7207 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7208 
      self.ucx.write(oprot)
7209 
      oprot.writeFieldEnd()
7210 
    oprot.writeFieldStop()
7211 
    oprot.writeStructEnd()
7212 
 
3431 rajveer 7213 
  def validate(self):
7214 
    return
7215 
 
7216 
 
1894 vikas 7217 
  def __repr__(self):
7218 
    L = ['%s=%r' % (key, value)
7219 
      for key, value in self.__dict__.iteritems()]
7220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7221 
 
7222 
  def __eq__(self, other):
7223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7224 
 
7225 
  def __ne__(self, other):
7226 
    return not (self == other)
7227 
 
594 rajveer 7228 
class getDefaultAddressId_args:
7229 
  """
7230 
  Attributes:
7231 
   - userId
7232 
  """
7233 
 
7234 
  thrift_spec = (
7235 
    None, # 0
7236 
    (1, TType.I64, 'userId', None, None, ), # 1
7237 
  )
7238 
 
7239 
  def __init__(self, userId=None,):
7240 
    self.userId = userId
7241 
 
7242 
  def read(self, iprot):
7243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7245 
      return
7246 
    iprot.readStructBegin()
7247 
    while True:
7248 
      (fname, ftype, fid) = iprot.readFieldBegin()
7249 
      if ftype == TType.STOP:
7250 
        break
7251 
      if fid == 1:
7252 
        if ftype == TType.I64:
7253 
          self.userId = iprot.readI64();
7254 
        else:
7255 
          iprot.skip(ftype)
7256 
      else:
7257 
        iprot.skip(ftype)
7258 
      iprot.readFieldEnd()
7259 
    iprot.readStructEnd()
7260 
 
7261 
  def write(self, oprot):
7262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7264 
      return
7265 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7266 
    if self.userId is not None:
594 rajveer 7267 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7268 
      oprot.writeI64(self.userId)
7269 
      oprot.writeFieldEnd()
7270 
    oprot.writeFieldStop()
7271 
    oprot.writeStructEnd()
7272 
 
3431 rajveer 7273 
  def validate(self):
7274 
    return
7275 
 
7276 
 
594 rajveer 7277 
  def __repr__(self):
7278 
    L = ['%s=%r' % (key, value)
7279 
      for key, value in self.__dict__.iteritems()]
7280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7281 
 
7282 
  def __eq__(self, other):
7283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7284 
 
7285 
  def __ne__(self, other):
7286 
    return not (self == other)
7287 
 
7288 
class getDefaultAddressId_result:
7289 
  """
7290 
  Attributes:
7291 
   - success
7292 
   - ucx
7293 
  """
7294 
 
7295 
  thrift_spec = (
7296 
    (0, TType.I64, 'success', None, None, ), # 0
7297 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7298 
  )
7299 
 
7300 
  def __init__(self, success=None, ucx=None,):
7301 
    self.success = success
7302 
    self.ucx = ucx
7303 
 
7304 
  def read(self, iprot):
7305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7307 
      return
7308 
    iprot.readStructBegin()
7309 
    while True:
7310 
      (fname, ftype, fid) = iprot.readFieldBegin()
7311 
      if ftype == TType.STOP:
7312 
        break
7313 
      if fid == 0:
7314 
        if ftype == TType.I64:
7315 
          self.success = iprot.readI64();
7316 
        else:
7317 
          iprot.skip(ftype)
7318 
      elif fid == 1:
7319 
        if ftype == TType.STRUCT:
7320 
          self.ucx = UserContextException()
7321 
          self.ucx.read(iprot)
7322 
        else:
7323 
          iprot.skip(ftype)
7324 
      else:
7325 
        iprot.skip(ftype)
7326 
      iprot.readFieldEnd()
7327 
    iprot.readStructEnd()
7328 
 
7329 
  def write(self, oprot):
7330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7332 
      return
7333 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7334 
    if self.success is not None:
594 rajveer 7335 
      oprot.writeFieldBegin('success', TType.I64, 0)
7336 
      oprot.writeI64(self.success)
7337 
      oprot.writeFieldEnd()
3431 rajveer 7338 
    if self.ucx is not None:
594 rajveer 7339 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7340 
      self.ucx.write(oprot)
7341 
      oprot.writeFieldEnd()
7342 
    oprot.writeFieldStop()
7343 
    oprot.writeStructEnd()
7344 
 
3431 rajveer 7345 
  def validate(self):
7346 
    return
7347 
 
7348 
 
594 rajveer 7349 
  def __repr__(self):
7350 
    L = ['%s=%r' % (key, value)
7351 
      for key, value in self.__dict__.iteritems()]
7352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7353 
 
7354 
  def __eq__(self, other):
7355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7356 
 
7357 
  def __ne__(self, other):
7358 
    return not (self == other)
7359 
 
785 rajveer 7360 
class getDefaultPincode_args:
7361 
  """
7362 
  Attributes:
7363 
   - userId
7364 
  """
7365 
 
7366 
  thrift_spec = (
7367 
    None, # 0
7368 
    (1, TType.I64, 'userId', None, None, ), # 1
7369 
  )
7370 
 
7371 
  def __init__(self, userId=None,):
7372 
    self.userId = userId
7373 
 
7374 
  def read(self, iprot):
7375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7377 
      return
7378 
    iprot.readStructBegin()
7379 
    while True:
7380 
      (fname, ftype, fid) = iprot.readFieldBegin()
7381 
      if ftype == TType.STOP:
7382 
        break
7383 
      if fid == 1:
7384 
        if ftype == TType.I64:
7385 
          self.userId = iprot.readI64();
7386 
        else:
7387 
          iprot.skip(ftype)
7388 
      else:
7389 
        iprot.skip(ftype)
7390 
      iprot.readFieldEnd()
7391 
    iprot.readStructEnd()
7392 
 
7393 
  def write(self, oprot):
7394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7396 
      return
7397 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7398 
    if self.userId is not None:
785 rajveer 7399 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7400 
      oprot.writeI64(self.userId)
7401 
      oprot.writeFieldEnd()
7402 
    oprot.writeFieldStop()
7403 
    oprot.writeStructEnd()
7404 
 
3431 rajveer 7405 
  def validate(self):
7406 
    return
7407 
 
7408 
 
785 rajveer 7409 
  def __repr__(self):
7410 
    L = ['%s=%r' % (key, value)
7411 
      for key, value in self.__dict__.iteritems()]
7412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7413 
 
7414 
  def __eq__(self, other):
7415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7416 
 
7417 
  def __ne__(self, other):
7418 
    return not (self == other)
7419 
 
7420 
class getDefaultPincode_result:
7421 
  """
7422 
  Attributes:
7423 
   - success
7424 
   - ucx
7425 
  """
7426 
 
7427 
  thrift_spec = (
7428 
    (0, TType.STRING, 'success', None, None, ), # 0
7429 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7430 
  )
7431 
 
7432 
  def __init__(self, success=None, ucx=None,):
7433 
    self.success = success
7434 
    self.ucx = ucx
7435 
 
7436 
  def read(self, iprot):
7437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7439 
      return
7440 
    iprot.readStructBegin()
7441 
    while True:
7442 
      (fname, ftype, fid) = iprot.readFieldBegin()
7443 
      if ftype == TType.STOP:
7444 
        break
7445 
      if fid == 0:
7446 
        if ftype == TType.STRING:
7447 
          self.success = iprot.readString();
7448 
        else:
7449 
          iprot.skip(ftype)
7450 
      elif fid == 1:
7451 
        if ftype == TType.STRUCT:
7452 
          self.ucx = UserContextException()
7453 
          self.ucx.read(iprot)
7454 
        else:
7455 
          iprot.skip(ftype)
7456 
      else:
7457 
        iprot.skip(ftype)
7458 
      iprot.readFieldEnd()
7459 
    iprot.readStructEnd()
7460 
 
7461 
  def write(self, oprot):
7462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7464 
      return
7465 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7466 
    if self.success is not None:
785 rajveer 7467 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7468 
      oprot.writeString(self.success)
7469 
      oprot.writeFieldEnd()
3431 rajveer 7470 
    if self.ucx is not None:
785 rajveer 7471 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7472 
      self.ucx.write(oprot)
7473 
      oprot.writeFieldEnd()
7474 
    oprot.writeFieldStop()
7475 
    oprot.writeStructEnd()
7476 
 
3431 rajveer 7477 
  def validate(self):
7478 
    return
7479 
 
7480 
 
785 rajveer 7481 
  def __repr__(self):
7482 
    L = ['%s=%r' % (key, value)
7483 
      for key, value in self.__dict__.iteritems()]
7484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7485 
 
7486 
  def __eq__(self, other):
7487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7488 
 
7489 
  def __ne__(self, other):
7490 
    return not (self == other)
7491 
 
1274 varun.gupt 7492 
class saveUserCommunication_args:
7493 
  """
7494 
  Attributes:
7495 
   - userId
7496 
   - replyTo
7497 
   - communicationType
7498 
   - orderId
7499 
   - airwaybillNo
7500 
   - productName
7501 
   - subject
7502 
   - message
7503 
  """
7504 
 
7505 
  thrift_spec = (
7506 
    None, # 0
7507 
    (1, TType.I64, 'userId', None, None, ), # 1
7508 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7509 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7510 
    (4, TType.I64, 'orderId', None, None, ), # 4
7511 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7512 
    (6, TType.STRING, 'productName', None, None, ), # 6
7513 
    (7, TType.STRING, 'subject', None, None, ), # 7
7514 
    (8, TType.STRING, 'message', None, None, ), # 8
7515 
  )
7516 
 
7517 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7518 
    self.userId = userId
7519 
    self.replyTo = replyTo
7520 
    self.communicationType = communicationType
7521 
    self.orderId = orderId
7522 
    self.airwaybillNo = airwaybillNo
7523 
    self.productName = productName
7524 
    self.subject = subject
7525 
    self.message = message
7526 
 
7527 
  def read(self, iprot):
7528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7530 
      return
7531 
    iprot.readStructBegin()
7532 
    while True:
7533 
      (fname, ftype, fid) = iprot.readFieldBegin()
7534 
      if ftype == TType.STOP:
7535 
        break
7536 
      if fid == 1:
7537 
        if ftype == TType.I64:
7538 
          self.userId = iprot.readI64();
7539 
        else:
7540 
          iprot.skip(ftype)
7541 
      elif fid == 2:
7542 
        if ftype == TType.STRING:
7543 
          self.replyTo = iprot.readString();
7544 
        else:
7545 
          iprot.skip(ftype)
7546 
      elif fid == 3:
7547 
        if ftype == TType.I64:
7548 
          self.communicationType = iprot.readI64();
7549 
        else:
7550 
          iprot.skip(ftype)
7551 
      elif fid == 4:
7552 
        if ftype == TType.I64:
7553 
          self.orderId = iprot.readI64();
7554 
        else:
7555 
          iprot.skip(ftype)
7556 
      elif fid == 5:
7557 
        if ftype == TType.STRING:
7558 
          self.airwaybillNo = iprot.readString();
7559 
        else:
7560 
          iprot.skip(ftype)
7561 
      elif fid == 6:
7562 
        if ftype == TType.STRING:
7563 
          self.productName = iprot.readString();
7564 
        else:
7565 
          iprot.skip(ftype)
7566 
      elif fid == 7:
7567 
        if ftype == TType.STRING:
7568 
          self.subject = iprot.readString();
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      elif fid == 8:
7572 
        if ftype == TType.STRING:
7573 
          self.message = iprot.readString();
7574 
        else:
7575 
          iprot.skip(ftype)
7576 
      else:
7577 
        iprot.skip(ftype)
7578 
      iprot.readFieldEnd()
7579 
    iprot.readStructEnd()
7580 
 
7581 
  def write(self, oprot):
7582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7584 
      return
7585 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7586 
    if self.userId is not None:
1274 varun.gupt 7587 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7588 
      oprot.writeI64(self.userId)
7589 
      oprot.writeFieldEnd()
3431 rajveer 7590 
    if self.replyTo is not None:
1274 varun.gupt 7591 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7592 
      oprot.writeString(self.replyTo)
7593 
      oprot.writeFieldEnd()
3431 rajveer 7594 
    if self.communicationType is not None:
1274 varun.gupt 7595 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7596 
      oprot.writeI64(self.communicationType)
7597 
      oprot.writeFieldEnd()
3431 rajveer 7598 
    if self.orderId is not None:
1274 varun.gupt 7599 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7600 
      oprot.writeI64(self.orderId)
7601 
      oprot.writeFieldEnd()
3431 rajveer 7602 
    if self.airwaybillNo is not None:
1274 varun.gupt 7603 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7604 
      oprot.writeString(self.airwaybillNo)
7605 
      oprot.writeFieldEnd()
3431 rajveer 7606 
    if self.productName is not None:
1274 varun.gupt 7607 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7608 
      oprot.writeString(self.productName)
7609 
      oprot.writeFieldEnd()
3431 rajveer 7610 
    if self.subject is not None:
1274 varun.gupt 7611 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7612 
      oprot.writeString(self.subject)
7613 
      oprot.writeFieldEnd()
3431 rajveer 7614 
    if self.message is not None:
1274 varun.gupt 7615 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7616 
      oprot.writeString(self.message)
7617 
      oprot.writeFieldEnd()
7618 
    oprot.writeFieldStop()
7619 
    oprot.writeStructEnd()
7620 
 
3431 rajveer 7621 
  def validate(self):
7622 
    return
7623 
 
7624 
 
1274 varun.gupt 7625 
  def __repr__(self):
7626 
    L = ['%s=%r' % (key, value)
7627 
      for key, value in self.__dict__.iteritems()]
7628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7629 
 
7630 
  def __eq__(self, other):
7631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7632 
 
7633 
  def __ne__(self, other):
7634 
    return not (self == other)
7635 
 
7636 
class saveUserCommunication_result:
7637 
  """
7638 
  Attributes:
7639 
   - success
7640 
   - ucx
7641 
  """
7642 
 
7643 
  thrift_spec = (
7644 
    (0, TType.BOOL, 'success', None, None, ), # 0
7645 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7646 
  )
7647 
 
7648 
  def __init__(self, success=None, ucx=None,):
7649 
    self.success = success
7650 
    self.ucx = ucx
7651 
 
7652 
  def read(self, iprot):
7653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7655 
      return
7656 
    iprot.readStructBegin()
7657 
    while True:
7658 
      (fname, ftype, fid) = iprot.readFieldBegin()
7659 
      if ftype == TType.STOP:
7660 
        break
7661 
      if fid == 0:
7662 
        if ftype == TType.BOOL:
7663 
          self.success = iprot.readBool();
7664 
        else:
7665 
          iprot.skip(ftype)
7666 
      elif fid == 1:
7667 
        if ftype == TType.STRUCT:
7668 
          self.ucx = UserCommunicationException()
7669 
          self.ucx.read(iprot)
7670 
        else:
7671 
          iprot.skip(ftype)
7672 
      else:
7673 
        iprot.skip(ftype)
7674 
      iprot.readFieldEnd()
7675 
    iprot.readStructEnd()
7676 
 
7677 
  def write(self, oprot):
7678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7680 
      return
7681 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7682 
    if self.success is not None:
1274 varun.gupt 7683 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7684 
      oprot.writeBool(self.success)
7685 
      oprot.writeFieldEnd()
3431 rajveer 7686 
    if self.ucx is not None:
1274 varun.gupt 7687 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7688 
      self.ucx.write(oprot)
7689 
      oprot.writeFieldEnd()
7690 
    oprot.writeFieldStop()
7691 
    oprot.writeStructEnd()
7692 
 
3431 rajveer 7693 
  def validate(self):
7694 
    return
7695 
 
7696 
 
1274 varun.gupt 7697 
  def __repr__(self):
7698 
    L = ['%s=%r' % (key, value)
7699 
      for key, value in self.__dict__.iteritems()]
7700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7701 
 
7702 
  def __eq__(self, other):
7703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7704 
 
7705 
  def __ne__(self, other):
7706 
    return not (self == other)
7707 
 
1590 varun.gupt 7708 
class getUserCommunicationById_args:
7709 
  """
7710 
  Attributes:
7711 
   - id
7712 
  """
7713 
 
7714 
  thrift_spec = (
7715 
    None, # 0
7716 
    (1, TType.I64, 'id', None, None, ), # 1
7717 
  )
7718 
 
7719 
  def __init__(self, id=None,):
7720 
    self.id = id
7721 
 
7722 
  def read(self, iprot):
7723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7725 
      return
7726 
    iprot.readStructBegin()
7727 
    while True:
7728 
      (fname, ftype, fid) = iprot.readFieldBegin()
7729 
      if ftype == TType.STOP:
7730 
        break
7731 
      if fid == 1:
7732 
        if ftype == TType.I64:
7733 
          self.id = iprot.readI64();
7734 
        else:
7735 
          iprot.skip(ftype)
7736 
      else:
7737 
        iprot.skip(ftype)
7738 
      iprot.readFieldEnd()
7739 
    iprot.readStructEnd()
7740 
 
7741 
  def write(self, oprot):
7742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7744 
      return
7745 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7746 
    if self.id is not None:
1590 varun.gupt 7747 
      oprot.writeFieldBegin('id', TType.I64, 1)
7748 
      oprot.writeI64(self.id)
7749 
      oprot.writeFieldEnd()
7750 
    oprot.writeFieldStop()
7751 
    oprot.writeStructEnd()
7752 
 
3431 rajveer 7753 
  def validate(self):
7754 
    return
7755 
 
7756 
 
1590 varun.gupt 7757 
  def __repr__(self):
7758 
    L = ['%s=%r' % (key, value)
7759 
      for key, value in self.__dict__.iteritems()]
7760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7761 
 
7762 
  def __eq__(self, other):
7763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7764 
 
7765 
  def __ne__(self, other):
7766 
    return not (self == other)
7767 
 
7768 
class getUserCommunicationById_result:
7769 
  """
7770 
  Attributes:
7771 
   - success
7772 
   - ucx
7773 
  """
7774 
 
7775 
  thrift_spec = (
7776 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7777 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7778 
  )
7779 
 
7780 
  def __init__(self, success=None, ucx=None,):
7781 
    self.success = success
7782 
    self.ucx = ucx
7783 
 
7784 
  def read(self, iprot):
7785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7787 
      return
7788 
    iprot.readStructBegin()
7789 
    while True:
7790 
      (fname, ftype, fid) = iprot.readFieldBegin()
7791 
      if ftype == TType.STOP:
7792 
        break
7793 
      if fid == 0:
7794 
        if ftype == TType.STRUCT:
7795 
          self.success = UserCommunication()
7796 
          self.success.read(iprot)
7797 
        else:
7798 
          iprot.skip(ftype)
7799 
      elif fid == 1:
7800 
        if ftype == TType.STRUCT:
7801 
          self.ucx = UserCommunicationException()
7802 
          self.ucx.read(iprot)
7803 
        else:
7804 
          iprot.skip(ftype)
7805 
      else:
7806 
        iprot.skip(ftype)
7807 
      iprot.readFieldEnd()
7808 
    iprot.readStructEnd()
7809 
 
7810 
  def write(self, oprot):
7811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7813 
      return
7814 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7815 
    if self.success is not None:
1590 varun.gupt 7816 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7817 
      self.success.write(oprot)
7818 
      oprot.writeFieldEnd()
3431 rajveer 7819 
    if self.ucx is not None:
1590 varun.gupt 7820 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7821 
      self.ucx.write(oprot)
7822 
      oprot.writeFieldEnd()
7823 
    oprot.writeFieldStop()
7824 
    oprot.writeStructEnd()
7825 
 
3431 rajveer 7826 
  def validate(self):
7827 
    return
7828 
 
7829 
 
1590 varun.gupt 7830 
  def __repr__(self):
7831 
    L = ['%s=%r' % (key, value)
7832 
      for key, value in self.__dict__.iteritems()]
7833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7834 
 
7835 
  def __eq__(self, other):
7836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7837 
 
7838 
  def __ne__(self, other):
7839 
    return not (self == other)
7840 
 
7841 
class getUserCommunicationByUser_args:
7842 
  """
7843 
  Attributes:
7844 
   - userId
7845 
  """
7846 
 
7847 
  thrift_spec = (
7848 
    None, # 0
7849 
    (1, TType.I64, 'userId', None, None, ), # 1
7850 
  )
7851 
 
7852 
  def __init__(self, userId=None,):
7853 
    self.userId = userId
7854 
 
7855 
  def read(self, iprot):
7856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7858 
      return
7859 
    iprot.readStructBegin()
7860 
    while True:
7861 
      (fname, ftype, fid) = iprot.readFieldBegin()
7862 
      if ftype == TType.STOP:
7863 
        break
7864 
      if fid == 1:
7865 
        if ftype == TType.I64:
7866 
          self.userId = iprot.readI64();
7867 
        else:
7868 
          iprot.skip(ftype)
7869 
      else:
7870 
        iprot.skip(ftype)
7871 
      iprot.readFieldEnd()
7872 
    iprot.readStructEnd()
7873 
 
7874 
  def write(self, oprot):
7875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7877 
      return
7878 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7879 
    if self.userId is not None:
1590 varun.gupt 7880 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7881 
      oprot.writeI64(self.userId)
7882 
      oprot.writeFieldEnd()
7883 
    oprot.writeFieldStop()
7884 
    oprot.writeStructEnd()
7885 
 
3431 rajveer 7886 
  def validate(self):
7887 
    return
7888 
 
7889 
 
1590 varun.gupt 7890 
  def __repr__(self):
7891 
    L = ['%s=%r' % (key, value)
7892 
      for key, value in self.__dict__.iteritems()]
7893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7894 
 
7895 
  def __eq__(self, other):
7896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7897 
 
7898 
  def __ne__(self, other):
7899 
    return not (self == other)
7900 
 
7901 
class getUserCommunicationByUser_result:
7902 
  """
7903 
  Attributes:
7904 
   - success
7905 
   - ucx
7906 
  """
7907 
 
7908 
  thrift_spec = (
7909 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7910 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7911 
  )
7912 
 
7913 
  def __init__(self, success=None, ucx=None,):
7914 
    self.success = success
7915 
    self.ucx = ucx
7916 
 
7917 
  def read(self, iprot):
7918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7920 
      return
7921 
    iprot.readStructBegin()
7922 
    while True:
7923 
      (fname, ftype, fid) = iprot.readFieldBegin()
7924 
      if ftype == TType.STOP:
7925 
        break
7926 
      if fid == 0:
7927 
        if ftype == TType.LIST:
7928 
          self.success = []
11592 amit.gupta 7929 
          (_etype107, _size104) = iprot.readListBegin()
7930 
          for _i108 in xrange(_size104):
7931 
            _elem109 = UserCommunication()
7932 
            _elem109.read(iprot)
7933 
            self.success.append(_elem109)
1590 varun.gupt 7934 
          iprot.readListEnd()
7935 
        else:
7936 
          iprot.skip(ftype)
7937 
      elif fid == 1:
7938 
        if ftype == TType.STRUCT:
7939 
          self.ucx = UserCommunicationException()
7940 
          self.ucx.read(iprot)
7941 
        else:
7942 
          iprot.skip(ftype)
7943 
      else:
7944 
        iprot.skip(ftype)
7945 
      iprot.readFieldEnd()
7946 
    iprot.readStructEnd()
7947 
 
7948 
  def write(self, oprot):
7949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7951 
      return
7952 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 7953 
    if self.success is not None:
1590 varun.gupt 7954 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7955 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7956 
      for iter110 in self.success:
7957 
        iter110.write(oprot)
1590 varun.gupt 7958 
      oprot.writeListEnd()
7959 
      oprot.writeFieldEnd()
3431 rajveer 7960 
    if self.ucx is not None:
1590 varun.gupt 7961 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7962 
      self.ucx.write(oprot)
7963 
      oprot.writeFieldEnd()
7964 
    oprot.writeFieldStop()
7965 
    oprot.writeStructEnd()
7966 
 
3431 rajveer 7967 
  def validate(self):
7968 
    return
7969 
 
7970 
 
1590 varun.gupt 7971 
  def __repr__(self):
7972 
    L = ['%s=%r' % (key, value)
7973 
      for key, value in self.__dict__.iteritems()]
7974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7975 
 
7976 
  def __eq__(self, other):
7977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7978 
 
7979 
  def __ne__(self, other):
7980 
    return not (self == other)
7981 
 
7982 
class getAllUserCommunications_args:
7983 
 
7984 
  thrift_spec = (
7985 
  )
7986 
 
7987 
  def read(self, iprot):
7988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7990 
      return
7991 
    iprot.readStructBegin()
7992 
    while True:
7993 
      (fname, ftype, fid) = iprot.readFieldBegin()
7994 
      if ftype == TType.STOP:
7995 
        break
7996 
      else:
7997 
        iprot.skip(ftype)
7998 
      iprot.readFieldEnd()
7999 
    iprot.readStructEnd()
8000 
 
8001 
  def write(self, oprot):
8002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8004 
      return
8005 
    oprot.writeStructBegin('getAllUserCommunications_args')
8006 
    oprot.writeFieldStop()
8007 
    oprot.writeStructEnd()
8008 
 
3431 rajveer 8009 
  def validate(self):
8010 
    return
8011 
 
8012 
 
1590 varun.gupt 8013 
  def __repr__(self):
8014 
    L = ['%s=%r' % (key, value)
8015 
      for key, value in self.__dict__.iteritems()]
8016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8017 
 
8018 
  def __eq__(self, other):
8019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8020 
 
8021 
  def __ne__(self, other):
8022 
    return not (self == other)
8023 
 
8024 
class getAllUserCommunications_result:
8025 
  """
8026 
  Attributes:
8027 
   - success
8028 
   - ucx
8029 
  """
8030 
 
8031 
  thrift_spec = (
8032 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8033 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8034 
  )
8035 
 
8036 
  def __init__(self, success=None, ucx=None,):
8037 
    self.success = success
8038 
    self.ucx = ucx
8039 
 
8040 
  def read(self, iprot):
8041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8043 
      return
8044 
    iprot.readStructBegin()
8045 
    while True:
8046 
      (fname, ftype, fid) = iprot.readFieldBegin()
8047 
      if ftype == TType.STOP:
8048 
        break
8049 
      if fid == 0:
8050 
        if ftype == TType.LIST:
8051 
          self.success = []
11592 amit.gupta 8052 
          (_etype114, _size111) = iprot.readListBegin()
8053 
          for _i115 in xrange(_size111):
8054 
            _elem116 = UserCommunication()
8055 
            _elem116.read(iprot)
8056 
            self.success.append(_elem116)
1590 varun.gupt 8057 
          iprot.readListEnd()
8058 
        else:
8059 
          iprot.skip(ftype)
8060 
      elif fid == 1:
8061 
        if ftype == TType.STRUCT:
8062 
          self.ucx = UserCommunicationException()
8063 
          self.ucx.read(iprot)
8064 
        else:
8065 
          iprot.skip(ftype)
8066 
      else:
8067 
        iprot.skip(ftype)
8068 
      iprot.readFieldEnd()
8069 
    iprot.readStructEnd()
8070 
 
8071 
  def write(self, oprot):
8072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8074 
      return
8075 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8076 
    if self.success is not None:
1590 varun.gupt 8077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8078 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8079 
      for iter117 in self.success:
8080 
        iter117.write(oprot)
1590 varun.gupt 8081 
      oprot.writeListEnd()
8082 
      oprot.writeFieldEnd()
3431 rajveer 8083 
    if self.ucx is not None:
1590 varun.gupt 8084 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8085 
      self.ucx.write(oprot)
8086 
      oprot.writeFieldEnd()
8087 
    oprot.writeFieldStop()
8088 
    oprot.writeStructEnd()
8089 
 
3431 rajveer 8090 
  def validate(self):
8091 
    return
8092 
 
8093 
 
1590 varun.gupt 8094 
  def __repr__(self):
8095 
    L = ['%s=%r' % (key, value)
8096 
      for key, value in self.__dict__.iteritems()]
8097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8098 
 
8099 
  def __eq__(self, other):
8100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8101 
 
8102 
  def __ne__(self, other):
8103 
    return not (self == other)
8104 
 
5407 amar.kumar 8105 
class removeUserCommunication_args:
8106 
  """
8107 
  Attributes:
8108 
   - id
8109 
  """
8110 
 
8111 
  thrift_spec = (
8112 
    None, # 0
8113 
    (1, TType.I64, 'id', None, None, ), # 1
8114 
  )
8115 
 
8116 
  def __init__(self, id=None,):
8117 
    self.id = id
8118 
 
8119 
  def read(self, iprot):
8120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8122 
      return
8123 
    iprot.readStructBegin()
8124 
    while True:
8125 
      (fname, ftype, fid) = iprot.readFieldBegin()
8126 
      if ftype == TType.STOP:
8127 
        break
8128 
      if fid == 1:
8129 
        if ftype == TType.I64:
8130 
          self.id = iprot.readI64();
8131 
        else:
8132 
          iprot.skip(ftype)
8133 
      else:
8134 
        iprot.skip(ftype)
8135 
      iprot.readFieldEnd()
8136 
    iprot.readStructEnd()
8137 
 
8138 
  def write(self, oprot):
8139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8141 
      return
8142 
    oprot.writeStructBegin('removeUserCommunication_args')
8143 
    if self.id is not None:
8144 
      oprot.writeFieldBegin('id', TType.I64, 1)
8145 
      oprot.writeI64(self.id)
8146 
      oprot.writeFieldEnd()
8147 
    oprot.writeFieldStop()
8148 
    oprot.writeStructEnd()
8149 
 
8150 
  def validate(self):
8151 
    return
8152 
 
8153 
 
8154 
  def __repr__(self):
8155 
    L = ['%s=%r' % (key, value)
8156 
      for key, value in self.__dict__.iteritems()]
8157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8158 
 
8159 
  def __eq__(self, other):
8160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8161 
 
8162 
  def __ne__(self, other):
8163 
    return not (self == other)
8164 
 
8165 
class removeUserCommunication_result:
8166 
  """
8167 
  Attributes:
8168 
   - ucx
8169 
  """
8170 
 
8171 
  thrift_spec = (
8172 
    None, # 0
8173 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8174 
  )
8175 
 
8176 
  def __init__(self, ucx=None,):
8177 
    self.ucx = ucx
8178 
 
8179 
  def read(self, iprot):
8180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8182 
      return
8183 
    iprot.readStructBegin()
8184 
    while True:
8185 
      (fname, ftype, fid) = iprot.readFieldBegin()
8186 
      if ftype == TType.STOP:
8187 
        break
8188 
      if fid == 1:
8189 
        if ftype == TType.STRUCT:
8190 
          self.ucx = UserCommunicationException()
8191 
          self.ucx.read(iprot)
8192 
        else:
8193 
          iprot.skip(ftype)
8194 
      else:
8195 
        iprot.skip(ftype)
8196 
      iprot.readFieldEnd()
8197 
    iprot.readStructEnd()
8198 
 
8199 
  def write(self, oprot):
8200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8202 
      return
8203 
    oprot.writeStructBegin('removeUserCommunication_result')
8204 
    if self.ucx is not None:
8205 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8206 
      self.ucx.write(oprot)
8207 
      oprot.writeFieldEnd()
8208 
    oprot.writeFieldStop()
8209 
    oprot.writeStructEnd()
8210 
 
8211 
  def validate(self):
8212 
    return
8213 
 
8214 
 
8215 
  def __repr__(self):
8216 
    L = ['%s=%r' % (key, value)
8217 
      for key, value in self.__dict__.iteritems()]
8218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8219 
 
8220 
  def __eq__(self, other):
8221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8222 
 
8223 
  def __ne__(self, other):
8224 
    return not (self == other)
8225 
 
1845 vikas 8226 
class createMasterAffiliate_args:
8227 
  """
8228 
  Attributes:
8229 
   - name
1859 vikas 8230 
   - addedOn
1845 vikas 8231 
  """
8232 
 
8233 
  thrift_spec = (
8234 
    None, # 0
8235 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8236 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8237 
  )
8238 
 
1859 vikas 8239 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8240 
    self.name = name
1859 vikas 8241 
    self.addedOn = addedOn
1845 vikas 8242 
 
8243 
  def read(self, iprot):
8244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8246 
      return
8247 
    iprot.readStructBegin()
8248 
    while True:
8249 
      (fname, ftype, fid) = iprot.readFieldBegin()
8250 
      if ftype == TType.STOP:
8251 
        break
8252 
      if fid == 1:
8253 
        if ftype == TType.STRING:
8254 
          self.name = iprot.readString();
8255 
        else:
8256 
          iprot.skip(ftype)
1859 vikas 8257 
      elif fid == 2:
8258 
        if ftype == TType.I64:
8259 
          self.addedOn = iprot.readI64();
8260 
        else:
8261 
          iprot.skip(ftype)
1845 vikas 8262 
      else:
8263 
        iprot.skip(ftype)
8264 
      iprot.readFieldEnd()
8265 
    iprot.readStructEnd()
8266 
 
8267 
  def write(self, oprot):
8268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8270 
      return
8271 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8272 
    if self.name is not None:
1845 vikas 8273 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8274 
      oprot.writeString(self.name)
8275 
      oprot.writeFieldEnd()
3431 rajveer 8276 
    if self.addedOn is not None:
1859 vikas 8277 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8278 
      oprot.writeI64(self.addedOn)
8279 
      oprot.writeFieldEnd()
1845 vikas 8280 
    oprot.writeFieldStop()
8281 
    oprot.writeStructEnd()
8282 
 
3431 rajveer 8283 
  def validate(self):
8284 
    return
8285 
 
8286 
 
1845 vikas 8287 
  def __repr__(self):
8288 
    L = ['%s=%r' % (key, value)
8289 
      for key, value in self.__dict__.iteritems()]
8290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8291 
 
8292 
  def __eq__(self, other):
8293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8294 
 
8295 
  def __ne__(self, other):
8296 
    return not (self == other)
8297 
 
8298 
class createMasterAffiliate_result:
8299 
  """
8300 
  Attributes:
8301 
   - success
8302 
   - utx
8303 
  """
8304 
 
8305 
  thrift_spec = (
8306 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8307 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8308 
  )
8309 
 
8310 
  def __init__(self, success=None, utx=None,):
8311 
    self.success = success
8312 
    self.utx = utx
8313 
 
8314 
  def read(self, iprot):
8315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8317 
      return
8318 
    iprot.readStructBegin()
8319 
    while True:
8320 
      (fname, ftype, fid) = iprot.readFieldBegin()
8321 
      if ftype == TType.STOP:
8322 
        break
8323 
      if fid == 0:
8324 
        if ftype == TType.STRUCT:
8325 
          self.success = MasterAffiliate()
8326 
          self.success.read(iprot)
8327 
        else:
8328 
          iprot.skip(ftype)
8329 
      elif fid == 1:
8330 
        if ftype == TType.STRUCT:
1996 vikas 8331 
          self.utx = UserAffiliateException()
1845 vikas 8332 
          self.utx.read(iprot)
8333 
        else:
8334 
          iprot.skip(ftype)
8335 
      else:
8336 
        iprot.skip(ftype)
8337 
      iprot.readFieldEnd()
8338 
    iprot.readStructEnd()
8339 
 
8340 
  def write(self, oprot):
8341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8343 
      return
8344 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8345 
    if self.success is not None:
1845 vikas 8346 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8347 
      self.success.write(oprot)
8348 
      oprot.writeFieldEnd()
3431 rajveer 8349 
    if self.utx is not None:
1845 vikas 8350 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8351 
      self.utx.write(oprot)
8352 
      oprot.writeFieldEnd()
8353 
    oprot.writeFieldStop()
8354 
    oprot.writeStructEnd()
8355 
 
3431 rajveer 8356 
  def validate(self):
8357 
    return
8358 
 
8359 
 
1845 vikas 8360 
  def __repr__(self):
8361 
    L = ['%s=%r' % (key, value)
8362 
      for key, value in self.__dict__.iteritems()]
8363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8364 
 
8365 
  def __eq__(self, other):
8366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8367 
 
8368 
  def __ne__(self, other):
8369 
    return not (self == other)
8370 
 
1899 vikas 8371 
class getAllMasterAffiliates_args:
8372 
 
8373 
  thrift_spec = (
8374 
  )
8375 
 
8376 
  def read(self, iprot):
8377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8379 
      return
8380 
    iprot.readStructBegin()
8381 
    while True:
8382 
      (fname, ftype, fid) = iprot.readFieldBegin()
8383 
      if ftype == TType.STOP:
8384 
        break
8385 
      else:
8386 
        iprot.skip(ftype)
8387 
      iprot.readFieldEnd()
8388 
    iprot.readStructEnd()
8389 
 
8390 
  def write(self, oprot):
8391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8393 
      return
8394 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8395 
    oprot.writeFieldStop()
8396 
    oprot.writeStructEnd()
8397 
 
3431 rajveer 8398 
  def validate(self):
8399 
    return
8400 
 
8401 
 
1899 vikas 8402 
  def __repr__(self):
8403 
    L = ['%s=%r' % (key, value)
8404 
      for key, value in self.__dict__.iteritems()]
8405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8406 
 
8407 
  def __eq__(self, other):
8408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8409 
 
8410 
  def __ne__(self, other):
8411 
    return not (self == other)
8412 
 
8413 
class getAllMasterAffiliates_result:
8414 
  """
8415 
  Attributes:
8416 
   - success
8417 
   - utx
8418 
  """
8419 
 
8420 
  thrift_spec = (
8421 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8422 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8423 
  )
8424 
 
8425 
  def __init__(self, success=None, utx=None,):
8426 
    self.success = success
8427 
    self.utx = utx
8428 
 
8429 
  def read(self, iprot):
8430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8432 
      return
8433 
    iprot.readStructBegin()
8434 
    while True:
8435 
      (fname, ftype, fid) = iprot.readFieldBegin()
8436 
      if ftype == TType.STOP:
8437 
        break
8438 
      if fid == 0:
8439 
        if ftype == TType.LIST:
8440 
          self.success = []
11592 amit.gupta 8441 
          (_etype121, _size118) = iprot.readListBegin()
8442 
          for _i122 in xrange(_size118):
8443 
            _elem123 = MasterAffiliate()
8444 
            _elem123.read(iprot)
8445 
            self.success.append(_elem123)
1899 vikas 8446 
          iprot.readListEnd()
8447 
        else:
8448 
          iprot.skip(ftype)
8449 
      elif fid == 1:
8450 
        if ftype == TType.STRUCT:
1996 vikas 8451 
          self.utx = UserAffiliateException()
1899 vikas 8452 
          self.utx.read(iprot)
8453 
        else:
8454 
          iprot.skip(ftype)
8455 
      else:
8456 
        iprot.skip(ftype)
8457 
      iprot.readFieldEnd()
8458 
    iprot.readStructEnd()
8459 
 
8460 
  def write(self, oprot):
8461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8463 
      return
8464 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8465 
    if self.success is not None:
1899 vikas 8466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8468 
      for iter124 in self.success:
8469 
        iter124.write(oprot)
1899 vikas 8470 
      oprot.writeListEnd()
8471 
      oprot.writeFieldEnd()
3431 rajveer 8472 
    if self.utx is not None:
1899 vikas 8473 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8474 
      self.utx.write(oprot)
8475 
      oprot.writeFieldEnd()
8476 
    oprot.writeFieldStop()
8477 
    oprot.writeStructEnd()
8478 
 
3431 rajveer 8479 
  def validate(self):
8480 
    return
8481 
 
8482 
 
1899 vikas 8483 
  def __repr__(self):
8484 
    L = ['%s=%r' % (key, value)
8485 
      for key, value in self.__dict__.iteritems()]
8486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8487 
 
8488 
  def __eq__(self, other):
8489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8490 
 
8491 
  def __ne__(self, other):
8492 
    return not (self == other)
8493 
 
1845 vikas 8494 
class getMasterAffiliateById_args:
8495 
  """
8496 
  Attributes:
8497 
   - id
8498 
  """
8499 
 
8500 
  thrift_spec = (
8501 
    None, # 0
8502 
    (1, TType.I64, 'id', None, None, ), # 1
8503 
  )
8504 
 
8505 
  def __init__(self, id=None,):
8506 
    self.id = id
8507 
 
8508 
  def read(self, iprot):
8509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8511 
      return
8512 
    iprot.readStructBegin()
8513 
    while True:
8514 
      (fname, ftype, fid) = iprot.readFieldBegin()
8515 
      if ftype == TType.STOP:
8516 
        break
8517 
      if fid == 1:
8518 
        if ftype == TType.I64:
8519 
          self.id = iprot.readI64();
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8532 
    if self.id is not None:
1845 vikas 8533 
      oprot.writeFieldBegin('id', TType.I64, 1)
8534 
      oprot.writeI64(self.id)
8535 
      oprot.writeFieldEnd()
8536 
    oprot.writeFieldStop()
8537 
    oprot.writeStructEnd()
8538 
 
3431 rajveer 8539 
  def validate(self):
8540 
    return
8541 
 
8542 
 
1845 vikas 8543 
  def __repr__(self):
8544 
    L = ['%s=%r' % (key, value)
8545 
      for key, value in self.__dict__.iteritems()]
8546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8547 
 
8548 
  def __eq__(self, other):
8549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8550 
 
8551 
  def __ne__(self, other):
8552 
    return not (self == other)
8553 
 
8554 
class getMasterAffiliateById_result:
8555 
  """
8556 
  Attributes:
8557 
   - success
8558 
   - utx
8559 
  """
8560 
 
8561 
  thrift_spec = (
8562 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8563 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8564 
  )
8565 
 
8566 
  def __init__(self, success=None, utx=None,):
8567 
    self.success = success
8568 
    self.utx = utx
8569 
 
8570 
  def read(self, iprot):
8571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8573 
      return
8574 
    iprot.readStructBegin()
8575 
    while True:
8576 
      (fname, ftype, fid) = iprot.readFieldBegin()
8577 
      if ftype == TType.STOP:
8578 
        break
8579 
      if fid == 0:
8580 
        if ftype == TType.STRUCT:
8581 
          self.success = MasterAffiliate()
8582 
          self.success.read(iprot)
8583 
        else:
8584 
          iprot.skip(ftype)
8585 
      elif fid == 1:
8586 
        if ftype == TType.STRUCT:
1996 vikas 8587 
          self.utx = UserAffiliateException()
1845 vikas 8588 
          self.utx.read(iprot)
8589 
        else:
8590 
          iprot.skip(ftype)
8591 
      else:
8592 
        iprot.skip(ftype)
8593 
      iprot.readFieldEnd()
8594 
    iprot.readStructEnd()
8595 
 
8596 
  def write(self, oprot):
8597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8599 
      return
8600 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8601 
    if self.success is not None:
1845 vikas 8602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8603 
      self.success.write(oprot)
8604 
      oprot.writeFieldEnd()
3431 rajveer 8605 
    if self.utx is not None:
1845 vikas 8606 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8607 
      self.utx.write(oprot)
8608 
      oprot.writeFieldEnd()
8609 
    oprot.writeFieldStop()
8610 
    oprot.writeStructEnd()
8611 
 
3431 rajveer 8612 
  def validate(self):
8613 
    return
8614 
 
8615 
 
1845 vikas 8616 
  def __repr__(self):
8617 
    L = ['%s=%r' % (key, value)
8618 
      for key, value in self.__dict__.iteritems()]
8619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8620 
 
8621 
  def __eq__(self, other):
8622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8623 
 
8624 
  def __ne__(self, other):
8625 
    return not (self == other)
8626 
 
8627 
class getMasterAffiliateByName_args:
8628 
  """
8629 
  Attributes:
8630 
   - name
8631 
  """
8632 
 
8633 
  thrift_spec = (
8634 
    None, # 0
8635 
    (1, TType.STRING, 'name', None, None, ), # 1
8636 
  )
8637 
 
8638 
  def __init__(self, name=None,):
8639 
    self.name = name
8640 
 
8641 
  def read(self, iprot):
8642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8644 
      return
8645 
    iprot.readStructBegin()
8646 
    while True:
8647 
      (fname, ftype, fid) = iprot.readFieldBegin()
8648 
      if ftype == TType.STOP:
8649 
        break
8650 
      if fid == 1:
8651 
        if ftype == TType.STRING:
8652 
          self.name = iprot.readString();
8653 
        else:
8654 
          iprot.skip(ftype)
8655 
      else:
8656 
        iprot.skip(ftype)
8657 
      iprot.readFieldEnd()
8658 
    iprot.readStructEnd()
8659 
 
8660 
  def write(self, oprot):
8661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8663 
      return
8664 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8665 
    if self.name is not None:
1845 vikas 8666 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8667 
      oprot.writeString(self.name)
8668 
      oprot.writeFieldEnd()
8669 
    oprot.writeFieldStop()
8670 
    oprot.writeStructEnd()
8671 
 
3431 rajveer 8672 
  def validate(self):
8673 
    return
8674 
 
8675 
 
1845 vikas 8676 
  def __repr__(self):
8677 
    L = ['%s=%r' % (key, value)
8678 
      for key, value in self.__dict__.iteritems()]
8679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8680 
 
8681 
  def __eq__(self, other):
8682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8683 
 
8684 
  def __ne__(self, other):
8685 
    return not (self == other)
8686 
 
8687 
class getMasterAffiliateByName_result:
8688 
  """
8689 
  Attributes:
8690 
   - success
8691 
   - utx
8692 
  """
8693 
 
8694 
  thrift_spec = (
8695 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8696 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8697 
  )
8698 
 
8699 
  def __init__(self, success=None, utx=None,):
8700 
    self.success = success
8701 
    self.utx = utx
8702 
 
8703 
  def read(self, iprot):
8704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8706 
      return
8707 
    iprot.readStructBegin()
8708 
    while True:
8709 
      (fname, ftype, fid) = iprot.readFieldBegin()
8710 
      if ftype == TType.STOP:
8711 
        break
8712 
      if fid == 0:
8713 
        if ftype == TType.STRUCT:
8714 
          self.success = MasterAffiliate()
8715 
          self.success.read(iprot)
8716 
        else:
8717 
          iprot.skip(ftype)
8718 
      elif fid == 1:
8719 
        if ftype == TType.STRUCT:
1996 vikas 8720 
          self.utx = UserAffiliateException()
1845 vikas 8721 
          self.utx.read(iprot)
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      else:
8725 
        iprot.skip(ftype)
8726 
      iprot.readFieldEnd()
8727 
    iprot.readStructEnd()
8728 
 
8729 
  def write(self, oprot):
8730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8732 
      return
8733 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8734 
    if self.success is not None:
1845 vikas 8735 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8736 
      self.success.write(oprot)
8737 
      oprot.writeFieldEnd()
3431 rajveer 8738 
    if self.utx is not None:
1845 vikas 8739 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8740 
      self.utx.write(oprot)
8741 
      oprot.writeFieldEnd()
8742 
    oprot.writeFieldStop()
8743 
    oprot.writeStructEnd()
8744 
 
3431 rajveer 8745 
  def validate(self):
8746 
    return
8747 
 
8748 
 
1845 vikas 8749 
  def __repr__(self):
8750 
    L = ['%s=%r' % (key, value)
8751 
      for key, value in self.__dict__.iteritems()]
8752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8753 
 
8754 
  def __eq__(self, other):
8755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8756 
 
8757 
  def __ne__(self, other):
8758 
    return not (self == other)
8759 
 
8760 
class createAffiliate_args:
8761 
  """
8762 
  Attributes:
8763 
   - name
8764 
   - url
8765 
   - masterAffiliateId
1859 vikas 8766 
   - addedOn
1845 vikas 8767 
  """
8768 
 
8769 
  thrift_spec = (
8770 
    None, # 0
8771 
    (1, TType.STRING, 'name', None, None, ), # 1
8772 
    (2, TType.STRING, 'url', None, None, ), # 2
8773 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8774 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8775 
  )
8776 
 
1859 vikas 8777 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8778 
    self.name = name
8779 
    self.url = url
8780 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8781 
    self.addedOn = addedOn
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.STRING:
8794 
          self.name = iprot.readString();
8795 
        else:
8796 
          iprot.skip(ftype)
8797 
      elif fid == 2:
8798 
        if ftype == TType.STRING:
8799 
          self.url = iprot.readString();
8800 
        else:
8801 
          iprot.skip(ftype)
8802 
      elif fid == 3:
8803 
        if ftype == TType.I64:
8804 
          self.masterAffiliateId = iprot.readI64();
8805 
        else:
8806 
          iprot.skip(ftype)
1859 vikas 8807 
      elif fid == 4:
8808 
        if ftype == TType.I64:
8809 
          self.addedOn = iprot.readI64();
8810 
        else:
8811 
          iprot.skip(ftype)
1845 vikas 8812 
      else:
8813 
        iprot.skip(ftype)
8814 
      iprot.readFieldEnd()
8815 
    iprot.readStructEnd()
8816 
 
8817 
  def write(self, oprot):
8818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8820 
      return
8821 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8822 
    if self.name is not None:
1845 vikas 8823 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8824 
      oprot.writeString(self.name)
8825 
      oprot.writeFieldEnd()
3431 rajveer 8826 
    if self.url is not None:
1845 vikas 8827 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8828 
      oprot.writeString(self.url)
8829 
      oprot.writeFieldEnd()
3431 rajveer 8830 
    if self.masterAffiliateId is not None:
1845 vikas 8831 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8832 
      oprot.writeI64(self.masterAffiliateId)
8833 
      oprot.writeFieldEnd()
3431 rajveer 8834 
    if self.addedOn is not None:
1859 vikas 8835 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8836 
      oprot.writeI64(self.addedOn)
8837 
      oprot.writeFieldEnd()
1845 vikas 8838 
    oprot.writeFieldStop()
8839 
    oprot.writeStructEnd()
8840 
 
3431 rajveer 8841 
  def validate(self):
8842 
    return
8843 
 
8844 
 
1845 vikas 8845 
  def __repr__(self):
8846 
    L = ['%s=%r' % (key, value)
8847 
      for key, value in self.__dict__.iteritems()]
8848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8849 
 
8850 
  def __eq__(self, other):
8851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8852 
 
8853 
  def __ne__(self, other):
8854 
    return not (self == other)
8855 
 
8856 
class createAffiliate_result:
8857 
  """
8858 
  Attributes:
8859 
   - success
8860 
   - utx
8861 
  """
8862 
 
8863 
  thrift_spec = (
8864 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8865 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8866 
  )
8867 
 
8868 
  def __init__(self, success=None, utx=None,):
8869 
    self.success = success
8870 
    self.utx = utx
8871 
 
8872 
  def read(self, iprot):
8873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8875 
      return
8876 
    iprot.readStructBegin()
8877 
    while True:
8878 
      (fname, ftype, fid) = iprot.readFieldBegin()
8879 
      if ftype == TType.STOP:
8880 
        break
8881 
      if fid == 0:
8882 
        if ftype == TType.STRUCT:
8883 
          self.success = Affiliate()
8884 
          self.success.read(iprot)
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      elif fid == 1:
8888 
        if ftype == TType.STRUCT:
1996 vikas 8889 
          self.utx = UserAffiliateException()
1845 vikas 8890 
          self.utx.read(iprot)
8891 
        else:
8892 
          iprot.skip(ftype)
8893 
      else:
8894 
        iprot.skip(ftype)
8895 
      iprot.readFieldEnd()
8896 
    iprot.readStructEnd()
8897 
 
8898 
  def write(self, oprot):
8899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8901 
      return
8902 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 8903 
    if self.success is not None:
1845 vikas 8904 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8905 
      self.success.write(oprot)
8906 
      oprot.writeFieldEnd()
3431 rajveer 8907 
    if self.utx is not None:
1845 vikas 8908 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8909 
      self.utx.write(oprot)
8910 
      oprot.writeFieldEnd()
8911 
    oprot.writeFieldStop()
8912 
    oprot.writeStructEnd()
8913 
 
3431 rajveer 8914 
  def validate(self):
8915 
    return
8916 
 
8917 
 
1845 vikas 8918 
  def __repr__(self):
8919 
    L = ['%s=%r' % (key, value)
8920 
      for key, value in self.__dict__.iteritems()]
8921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8922 
 
8923 
  def __eq__(self, other):
8924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8925 
 
8926 
  def __ne__(self, other):
8927 
    return not (self == other)
8928 
 
8929 
class getAffiliateById_args:
8930 
  """
8931 
  Attributes:
8932 
   - id
8933 
  """
8934 
 
8935 
  thrift_spec = (
8936 
    None, # 0
8937 
    (1, TType.I64, 'id', None, None, ), # 1
8938 
  )
8939 
 
8940 
  def __init__(self, id=None,):
8941 
    self.id = id
8942 
 
8943 
  def read(self, iprot):
8944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8946 
      return
8947 
    iprot.readStructBegin()
8948 
    while True:
8949 
      (fname, ftype, fid) = iprot.readFieldBegin()
8950 
      if ftype == TType.STOP:
8951 
        break
8952 
      if fid == 1:
8953 
        if ftype == TType.I64:
8954 
          self.id = iprot.readI64();
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      else:
8958 
        iprot.skip(ftype)
8959 
      iprot.readFieldEnd()
8960 
    iprot.readStructEnd()
8961 
 
8962 
  def write(self, oprot):
8963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8965 
      return
8966 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 8967 
    if self.id is not None:
1845 vikas 8968 
      oprot.writeFieldBegin('id', TType.I64, 1)
8969 
      oprot.writeI64(self.id)
8970 
      oprot.writeFieldEnd()
8971 
    oprot.writeFieldStop()
8972 
    oprot.writeStructEnd()
8973 
 
3431 rajveer 8974 
  def validate(self):
8975 
    return
8976 
 
8977 
 
1845 vikas 8978 
  def __repr__(self):
8979 
    L = ['%s=%r' % (key, value)
8980 
      for key, value in self.__dict__.iteritems()]
8981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8982 
 
8983 
  def __eq__(self, other):
8984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8985 
 
8986 
  def __ne__(self, other):
8987 
    return not (self == other)
8988 
 
8989 
class getAffiliateById_result:
8990 
  """
8991 
  Attributes:
8992 
   - success
8993 
   - utx
8994 
  """
8995 
 
8996 
  thrift_spec = (
8997 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8998 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8999 
  )
9000 
 
9001 
  def __init__(self, success=None, utx=None,):
9002 
    self.success = success
9003 
    self.utx = utx
9004 
 
9005 
  def read(self, iprot):
9006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9008 
      return
9009 
    iprot.readStructBegin()
9010 
    while True:
9011 
      (fname, ftype, fid) = iprot.readFieldBegin()
9012 
      if ftype == TType.STOP:
9013 
        break
9014 
      if fid == 0:
9015 
        if ftype == TType.STRUCT:
9016 
          self.success = Affiliate()
9017 
          self.success.read(iprot)
9018 
        else:
9019 
          iprot.skip(ftype)
9020 
      elif fid == 1:
9021 
        if ftype == TType.STRUCT:
1996 vikas 9022 
          self.utx = UserAffiliateException()
1845 vikas 9023 
          self.utx.read(iprot)
9024 
        else:
9025 
          iprot.skip(ftype)
9026 
      else:
9027 
        iprot.skip(ftype)
9028 
      iprot.readFieldEnd()
9029 
    iprot.readStructEnd()
9030 
 
9031 
  def write(self, oprot):
9032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9034 
      return
9035 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9036 
    if self.success is not None:
1845 vikas 9037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9038 
      self.success.write(oprot)
9039 
      oprot.writeFieldEnd()
3431 rajveer 9040 
    if self.utx is not None:
1845 vikas 9041 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9042 
      self.utx.write(oprot)
9043 
      oprot.writeFieldEnd()
9044 
    oprot.writeFieldStop()
9045 
    oprot.writeStructEnd()
9046 
 
3431 rajveer 9047 
  def validate(self):
9048 
    return
9049 
 
9050 
 
1845 vikas 9051 
  def __repr__(self):
9052 
    L = ['%s=%r' % (key, value)
9053 
      for key, value in self.__dict__.iteritems()]
9054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9055 
 
9056 
  def __eq__(self, other):
9057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9058 
 
9059 
  def __ne__(self, other):
9060 
    return not (self == other)
9061 
 
9062 
class getAffiliateByName_args:
9063 
  """
9064 
  Attributes:
9065 
   - name
9066 
  """
9067 
 
9068 
  thrift_spec = (
9069 
    None, # 0
9070 
    (1, TType.STRING, 'name', None, None, ), # 1
9071 
  )
9072 
 
9073 
  def __init__(self, name=None,):
9074 
    self.name = name
9075 
 
9076 
  def read(self, iprot):
9077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9079 
      return
9080 
    iprot.readStructBegin()
9081 
    while True:
9082 
      (fname, ftype, fid) = iprot.readFieldBegin()
9083 
      if ftype == TType.STOP:
9084 
        break
9085 
      if fid == 1:
9086 
        if ftype == TType.STRING:
9087 
          self.name = iprot.readString();
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
9099 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9100 
    if self.name is not None:
1845 vikas 9101 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9102 
      oprot.writeString(self.name)
9103 
      oprot.writeFieldEnd()
9104 
    oprot.writeFieldStop()
9105 
    oprot.writeStructEnd()
9106 
 
3431 rajveer 9107 
  def validate(self):
9108 
    return
9109 
 
9110 
 
1845 vikas 9111 
  def __repr__(self):
9112 
    L = ['%s=%r' % (key, value)
9113 
      for key, value in self.__dict__.iteritems()]
9114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9115 
 
9116 
  def __eq__(self, other):
9117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9118 
 
9119 
  def __ne__(self, other):
9120 
    return not (self == other)
9121 
 
9122 
class getAffiliateByName_result:
9123 
  """
9124 
  Attributes:
9125 
   - success
9126 
   - utx
9127 
  """
9128 
 
9129 
  thrift_spec = (
9130 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9131 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9132 
  )
9133 
 
9134 
  def __init__(self, success=None, utx=None,):
9135 
    self.success = success
9136 
    self.utx = utx
9137 
 
9138 
  def read(self, iprot):
9139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9141 
      return
9142 
    iprot.readStructBegin()
9143 
    while True:
9144 
      (fname, ftype, fid) = iprot.readFieldBegin()
9145 
      if ftype == TType.STOP:
9146 
        break
9147 
      if fid == 0:
9148 
        if ftype == TType.STRUCT:
9149 
          self.success = Affiliate()
9150 
          self.success.read(iprot)
9151 
        else:
9152 
          iprot.skip(ftype)
9153 
      elif fid == 1:
9154 
        if ftype == TType.STRUCT:
1996 vikas 9155 
          self.utx = UserAffiliateException()
1845 vikas 9156 
          self.utx.read(iprot)
9157 
        else:
9158 
          iprot.skip(ftype)
9159 
      else:
9160 
        iprot.skip(ftype)
9161 
      iprot.readFieldEnd()
9162 
    iprot.readStructEnd()
9163 
 
9164 
  def write(self, oprot):
9165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9167 
      return
9168 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9169 
    if self.success is not None:
1845 vikas 9170 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9171 
      self.success.write(oprot)
9172 
      oprot.writeFieldEnd()
3431 rajveer 9173 
    if self.utx is not None:
1845 vikas 9174 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9175 
      self.utx.write(oprot)
9176 
      oprot.writeFieldEnd()
9177 
    oprot.writeFieldStop()
9178 
    oprot.writeStructEnd()
9179 
 
3431 rajveer 9180 
  def validate(self):
9181 
    return
9182 
 
9183 
 
1845 vikas 9184 
  def __repr__(self):
9185 
    L = ['%s=%r' % (key, value)
9186 
      for key, value in self.__dict__.iteritems()]
9187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9188 
 
9189 
  def __eq__(self, other):
9190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9191 
 
9192 
  def __ne__(self, other):
9193 
    return not (self == other)
9194 
 
1996 vikas 9195 
class getTrackerById_args:
1845 vikas 9196 
  """
9197 
  Attributes:
9198 
   - id
9199 
  """
9200 
 
9201 
  thrift_spec = (
9202 
    None, # 0
9203 
    (1, TType.I64, 'id', None, None, ), # 1
9204 
  )
9205 
 
9206 
  def __init__(self, id=None,):
9207 
    self.id = id
9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      if fid == 1:
9219 
        if ftype == TType.I64:
9220 
          self.id = iprot.readI64();
9221 
        else:
9222 
          iprot.skip(ftype)
9223 
      else:
9224 
        iprot.skip(ftype)
9225 
      iprot.readFieldEnd()
9226 
    iprot.readStructEnd()
9227 
 
9228 
  def write(self, oprot):
9229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9231 
      return
1996 vikas 9232 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9233 
    if self.id is not None:
1845 vikas 9234 
      oprot.writeFieldBegin('id', TType.I64, 1)
9235 
      oprot.writeI64(self.id)
9236 
      oprot.writeFieldEnd()
9237 
    oprot.writeFieldStop()
9238 
    oprot.writeStructEnd()
9239 
 
3431 rajveer 9240 
  def validate(self):
9241 
    return
9242 
 
9243 
 
1845 vikas 9244 
  def __repr__(self):
9245 
    L = ['%s=%r' % (key, value)
9246 
      for key, value in self.__dict__.iteritems()]
9247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9248 
 
9249 
  def __eq__(self, other):
9250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9251 
 
9252 
  def __ne__(self, other):
9253 
    return not (self == other)
9254 
 
9255 
class getTrackerById_result:
9256 
  """
9257 
  Attributes:
9258 
   - success
9259 
   - utx
9260 
  """
9261 
 
9262 
  thrift_spec = (
9263 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9264 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9265 
  )
9266 
 
9267 
  def __init__(self, success=None, utx=None,):
9268 
    self.success = success
9269 
    self.utx = utx
9270 
 
9271 
  def read(self, iprot):
9272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9274 
      return
9275 
    iprot.readStructBegin()
9276 
    while True:
9277 
      (fname, ftype, fid) = iprot.readFieldBegin()
9278 
      if ftype == TType.STOP:
9279 
        break
9280 
      if fid == 0:
9281 
        if ftype == TType.STRUCT:
9282 
          self.success = Tracker()
9283 
          self.success.read(iprot)
9284 
        else:
9285 
          iprot.skip(ftype)
9286 
      elif fid == 1:
9287 
        if ftype == TType.STRUCT:
1996 vikas 9288 
          self.utx = UserAffiliateException()
1845 vikas 9289 
          self.utx.read(iprot)
9290 
        else:
9291 
          iprot.skip(ftype)
9292 
      else:
9293 
        iprot.skip(ftype)
9294 
      iprot.readFieldEnd()
9295 
    iprot.readStructEnd()
9296 
 
9297 
  def write(self, oprot):
9298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9300 
      return
9301 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9302 
    if self.success is not None:
1845 vikas 9303 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9304 
      self.success.write(oprot)
9305 
      oprot.writeFieldEnd()
3431 rajveer 9306 
    if self.utx is not None:
1845 vikas 9307 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9308 
      self.utx.write(oprot)
9309 
      oprot.writeFieldEnd()
9310 
    oprot.writeFieldStop()
9311 
    oprot.writeStructEnd()
9312 
 
3431 rajveer 9313 
  def validate(self):
9314 
    return
9315 
 
9316 
 
1845 vikas 9317 
  def __repr__(self):
9318 
    L = ['%s=%r' % (key, value)
9319 
      for key, value in self.__dict__.iteritems()]
9320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9321 
 
9322 
  def __eq__(self, other):
9323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9324 
 
9325 
  def __ne__(self, other):
9326 
    return not (self == other)
9327 
 
1996 vikas 9328 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9329 
  """
9330 
  Attributes:
1996 vikas 9331 
   - id
1845 vikas 9332 
  """
9333 
 
9334 
  thrift_spec = (
9335 
    None, # 0
1996 vikas 9336 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9337 
  )
9338 
 
1996 vikas 9339 
  def __init__(self, id=None,):
9340 
    self.id = id
1845 vikas 9341 
 
9342 
  def read(self, iprot):
9343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9345 
      return
9346 
    iprot.readStructBegin()
9347 
    while True:
9348 
      (fname, ftype, fid) = iprot.readFieldBegin()
9349 
      if ftype == TType.STOP:
9350 
        break
9351 
      if fid == 1:
9352 
        if ftype == TType.I64:
1996 vikas 9353 
          self.id = iprot.readI64();
1845 vikas 9354 
        else:
9355 
          iprot.skip(ftype)
9356 
      else:
9357 
        iprot.skip(ftype)
9358 
      iprot.readFieldEnd()
9359 
    iprot.readStructEnd()
9360 
 
9361 
  def write(self, oprot):
9362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9364 
      return
1996 vikas 9365 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9366 
    if self.id is not None:
1996 vikas 9367 
      oprot.writeFieldBegin('id', TType.I64, 1)
9368 
      oprot.writeI64(self.id)
1845 vikas 9369 
      oprot.writeFieldEnd()
9370 
    oprot.writeFieldStop()
9371 
    oprot.writeStructEnd()
9372 
 
3431 rajveer 9373 
  def validate(self):
9374 
    return
9375 
 
9376 
 
1845 vikas 9377 
  def __repr__(self):
9378 
    L = ['%s=%r' % (key, value)
9379 
      for key, value in self.__dict__.iteritems()]
9380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9381 
 
9382 
  def __eq__(self, other):
9383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9384 
 
9385 
  def __ne__(self, other):
9386 
    return not (self == other)
9387 
 
1996 vikas 9388 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9389 
  """
9390 
  Attributes:
9391 
   - success
9392 
   - utx
9393 
  """
9394 
 
9395 
  thrift_spec = (
1996 vikas 9396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9397 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9398 
  )
9399 
 
9400 
  def __init__(self, success=None, utx=None,):
9401 
    self.success = success
9402 
    self.utx = utx
9403 
 
9404 
  def read(self, iprot):
9405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9407 
      return
9408 
    iprot.readStructBegin()
9409 
    while True:
9410 
      (fname, ftype, fid) = iprot.readFieldBegin()
9411 
      if ftype == TType.STOP:
9412 
        break
9413 
      if fid == 0:
9414 
        if ftype == TType.LIST:
9415 
          self.success = []
11592 amit.gupta 9416 
          (_etype128, _size125) = iprot.readListBegin()
9417 
          for _i129 in xrange(_size125):
9418 
            _elem130 = Affiliate()
9419 
            _elem130.read(iprot)
9420 
            self.success.append(_elem130)
1845 vikas 9421 
          iprot.readListEnd()
9422 
        else:
9423 
          iprot.skip(ftype)
9424 
      elif fid == 1:
9425 
        if ftype == TType.STRUCT:
1996 vikas 9426 
          self.utx = UserAffiliateException()
1845 vikas 9427 
          self.utx.read(iprot)
9428 
        else:
9429 
          iprot.skip(ftype)
9430 
      else:
9431 
        iprot.skip(ftype)
9432 
      iprot.readFieldEnd()
9433 
    iprot.readStructEnd()
9434 
 
9435 
  def write(self, oprot):
9436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9438 
      return
1996 vikas 9439 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9440 
    if self.success is not None:
1845 vikas 9441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9443 
      for iter131 in self.success:
9444 
        iter131.write(oprot)
1845 vikas 9445 
      oprot.writeListEnd()
9446 
      oprot.writeFieldEnd()
3431 rajveer 9447 
    if self.utx is not None:
1845 vikas 9448 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9449 
      self.utx.write(oprot)
9450 
      oprot.writeFieldEnd()
9451 
    oprot.writeFieldStop()
9452 
    oprot.writeStructEnd()
9453 
 
3431 rajveer 9454 
  def validate(self):
9455 
    return
9456 
 
9457 
 
1845 vikas 9458 
  def __repr__(self):
9459 
    L = ['%s=%r' % (key, value)
9460 
      for key, value in self.__dict__.iteritems()]
9461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9462 
 
9463 
  def __eq__(self, other):
9464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9465 
 
9466 
  def __ne__(self, other):
9467 
    return not (self == other)
9468 
 
9469 
class addTrackLog_args:
9470 
  """
9471 
  Attributes:
1996 vikas 9472 
   - affiliateId
1845 vikas 9473 
   - userId
9474 
   - event
9475 
   - url
9476 
   - data
1859 vikas 9477 
   - addedOn
1845 vikas 9478 
  """
9479 
 
9480 
  thrift_spec = (
9481 
    None, # 0
1996 vikas 9482 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9483 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9484 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9485 
    (4, TType.STRING, 'url', None, None, ), # 4
9486 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9487 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9488 
  )
9489 
 
1996 vikas 9490 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9491 
    self.affiliateId = affiliateId
1845 vikas 9492 
    self.userId = userId
9493 
    self.event = event
9494 
    self.url = url
9495 
    self.data = data
1859 vikas 9496 
    self.addedOn = addedOn
1845 vikas 9497 
 
9498 
  def read(self, iprot):
9499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9501 
      return
9502 
    iprot.readStructBegin()
9503 
    while True:
9504 
      (fname, ftype, fid) = iprot.readFieldBegin()
9505 
      if ftype == TType.STOP:
9506 
        break
9507 
      if fid == 1:
9508 
        if ftype == TType.I64:
1996 vikas 9509 
          self.affiliateId = iprot.readI64();
1845 vikas 9510 
        else:
9511 
          iprot.skip(ftype)
9512 
      elif fid == 2:
9513 
        if ftype == TType.I64:
9514 
          self.userId = iprot.readI64();
9515 
        else:
9516 
          iprot.skip(ftype)
9517 
      elif fid == 3:
3378 vikas 9518 
        if ftype == TType.I32:
9519 
          self.event = iprot.readI32();
1845 vikas 9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      elif fid == 4:
9523 
        if ftype == TType.STRING:
9524 
          self.url = iprot.readString();
9525 
        else:
9526 
          iprot.skip(ftype)
9527 
      elif fid == 5:
9528 
        if ftype == TType.STRING:
9529 
          self.data = iprot.readString();
9530 
        else:
9531 
          iprot.skip(ftype)
1859 vikas 9532 
      elif fid == 6:
9533 
        if ftype == TType.I64:
9534 
          self.addedOn = iprot.readI64();
9535 
        else:
9536 
          iprot.skip(ftype)
1845 vikas 9537 
      else:
9538 
        iprot.skip(ftype)
9539 
      iprot.readFieldEnd()
9540 
    iprot.readStructEnd()
9541 
 
9542 
  def write(self, oprot):
9543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9545 
      return
9546 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9547 
    if self.affiliateId is not None:
1996 vikas 9548 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9549 
      oprot.writeI64(self.affiliateId)
1845 vikas 9550 
      oprot.writeFieldEnd()
3431 rajveer 9551 
    if self.userId is not None:
1845 vikas 9552 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9553 
      oprot.writeI64(self.userId)
9554 
      oprot.writeFieldEnd()
3431 rajveer 9555 
    if self.event is not None:
3378 vikas 9556 
      oprot.writeFieldBegin('event', TType.I32, 3)
9557 
      oprot.writeI32(self.event)
1845 vikas 9558 
      oprot.writeFieldEnd()
3431 rajveer 9559 
    if self.url is not None:
1845 vikas 9560 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9561 
      oprot.writeString(self.url)
9562 
      oprot.writeFieldEnd()
3431 rajveer 9563 
    if self.data is not None:
1845 vikas 9564 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9565 
      oprot.writeString(self.data)
9566 
      oprot.writeFieldEnd()
3431 rajveer 9567 
    if self.addedOn is not None:
1859 vikas 9568 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9569 
      oprot.writeI64(self.addedOn)
9570 
      oprot.writeFieldEnd()
1845 vikas 9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
3431 rajveer 9574 
  def validate(self):
9575 
    return
9576 
 
9577 
 
1845 vikas 9578 
  def __repr__(self):
9579 
    L = ['%s=%r' % (key, value)
9580 
      for key, value in self.__dict__.iteritems()]
9581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9582 
 
9583 
  def __eq__(self, other):
9584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9585 
 
9586 
  def __ne__(self, other):
9587 
    return not (self == other)
9588 
 
9589 
class addTrackLog_result:
9590 
  """
9591 
  Attributes:
9592 
   - success
9593 
   - utx
9594 
  """
9595 
 
9596 
  thrift_spec = (
9597 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9598 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9599 
  )
9600 
 
9601 
  def __init__(self, success=None, utx=None,):
9602 
    self.success = success
9603 
    self.utx = utx
9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 0:
9615 
        if ftype == TType.I64:
9616 
          self.success = iprot.readI64();
9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      elif fid == 1:
9620 
        if ftype == TType.STRUCT:
1996 vikas 9621 
          self.utx = UserAffiliateException()
1845 vikas 9622 
          self.utx.read(iprot)
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
9634 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9635 
    if self.success is not None:
1845 vikas 9636 
      oprot.writeFieldBegin('success', TType.I64, 0)
9637 
      oprot.writeI64(self.success)
9638 
      oprot.writeFieldEnd()
3431 rajveer 9639 
    if self.utx is not None:
1845 vikas 9640 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9641 
      self.utx.write(oprot)
9642 
      oprot.writeFieldEnd()
9643 
    oprot.writeFieldStop()
9644 
    oprot.writeStructEnd()
9645 
 
3431 rajveer 9646 
  def validate(self):
9647 
    return
9648 
 
9649 
 
1845 vikas 9650 
  def __repr__(self):
9651 
    L = ['%s=%r' % (key, value)
9652 
      for key, value in self.__dict__.iteritems()]
9653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9654 
 
9655 
  def __eq__(self, other):
9656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9657 
 
9658 
  def __ne__(self, other):
9659 
    return not (self == other)
9660 
 
9661 
class getTrackLogById_args:
9662 
  """
9663 
  Attributes:
9664 
   - id
9665 
  """
9666 
 
9667 
  thrift_spec = (
9668 
    None, # 0
9669 
    (1, TType.I64, 'id', None, None, ), # 1
9670 
  )
9671 
 
9672 
  def __init__(self, id=None,):
9673 
    self.id = id
9674 
 
9675 
  def read(self, iprot):
9676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9678 
      return
9679 
    iprot.readStructBegin()
9680 
    while True:
9681 
      (fname, ftype, fid) = iprot.readFieldBegin()
9682 
      if ftype == TType.STOP:
9683 
        break
9684 
      if fid == 1:
9685 
        if ftype == TType.I64:
9686 
          self.id = iprot.readI64();
9687 
        else:
9688 
          iprot.skip(ftype)
9689 
      else:
9690 
        iprot.skip(ftype)
9691 
      iprot.readFieldEnd()
9692 
    iprot.readStructEnd()
9693 
 
9694 
  def write(self, oprot):
9695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9697 
      return
9698 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9699 
    if self.id is not None:
1845 vikas 9700 
      oprot.writeFieldBegin('id', TType.I64, 1)
9701 
      oprot.writeI64(self.id)
9702 
      oprot.writeFieldEnd()
9703 
    oprot.writeFieldStop()
9704 
    oprot.writeStructEnd()
9705 
 
3431 rajveer 9706 
  def validate(self):
9707 
    return
9708 
 
9709 
 
1845 vikas 9710 
  def __repr__(self):
9711 
    L = ['%s=%r' % (key, value)
9712 
      for key, value in self.__dict__.iteritems()]
9713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9714 
 
9715 
  def __eq__(self, other):
9716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9717 
 
9718 
  def __ne__(self, other):
9719 
    return not (self == other)
9720 
 
9721 
class getTrackLogById_result:
9722 
  """
9723 
  Attributes:
9724 
   - success
9725 
   - utx
9726 
  """
9727 
 
9728 
  thrift_spec = (
9729 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9730 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9731 
  )
9732 
 
9733 
  def __init__(self, success=None, utx=None,):
9734 
    self.success = success
9735 
    self.utx = utx
9736 
 
9737 
  def read(self, iprot):
9738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9740 
      return
9741 
    iprot.readStructBegin()
9742 
    while True:
9743 
      (fname, ftype, fid) = iprot.readFieldBegin()
9744 
      if ftype == TType.STOP:
9745 
        break
9746 
      if fid == 0:
9747 
        if ftype == TType.STRUCT:
9748 
          self.success = TrackLog()
9749 
          self.success.read(iprot)
9750 
        else:
9751 
          iprot.skip(ftype)
9752 
      elif fid == 1:
9753 
        if ftype == TType.STRUCT:
1996 vikas 9754 
          self.utx = UserAffiliateException()
1845 vikas 9755 
          self.utx.read(iprot)
9756 
        else:
9757 
          iprot.skip(ftype)
9758 
      else:
9759 
        iprot.skip(ftype)
9760 
      iprot.readFieldEnd()
9761 
    iprot.readStructEnd()
9762 
 
9763 
  def write(self, oprot):
9764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9766 
      return
9767 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9768 
    if self.success is not None:
1845 vikas 9769 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9770 
      self.success.write(oprot)
9771 
      oprot.writeFieldEnd()
3431 rajveer 9772 
    if self.utx is not None:
1845 vikas 9773 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9774 
      self.utx.write(oprot)
9775 
      oprot.writeFieldEnd()
9776 
    oprot.writeFieldStop()
9777 
    oprot.writeStructEnd()
9778 
 
3431 rajveer 9779 
  def validate(self):
9780 
    return
9781 
 
9782 
 
1845 vikas 9783 
  def __repr__(self):
9784 
    L = ['%s=%r' % (key, value)
9785 
      for key, value in self.__dict__.iteritems()]
9786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9787 
 
9788 
  def __eq__(self, other):
9789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9790 
 
9791 
  def __ne__(self, other):
9792 
    return not (self == other)
9793 
 
1996 vikas 9794 
class getTrackLogsByAffiliate_args:
1845 vikas 9795 
  """
9796 
  Attributes:
1996 vikas 9797 
   - affiliateId
3293 vikas 9798 
   - startDate
9799 
   - endDate
1845 vikas 9800 
  """
9801 
 
9802 
  thrift_spec = (
9803 
    None, # 0
1996 vikas 9804 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9805 
    (2, TType.I64, 'startDate', None, None, ), # 2
9806 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9807 
  )
9808 
 
3293 vikas 9809 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9810 
    self.affiliateId = affiliateId
3293 vikas 9811 
    self.startDate = startDate
9812 
    self.endDate = endDate
1845 vikas 9813 
 
9814 
  def read(self, iprot):
9815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9817 
      return
9818 
    iprot.readStructBegin()
9819 
    while True:
9820 
      (fname, ftype, fid) = iprot.readFieldBegin()
9821 
      if ftype == TType.STOP:
9822 
        break
9823 
      if fid == 1:
9824 
        if ftype == TType.I64:
1996 vikas 9825 
          self.affiliateId = iprot.readI64();
1845 vikas 9826 
        else:
9827 
          iprot.skip(ftype)
3293 vikas 9828 
      elif fid == 2:
9829 
        if ftype == TType.I64:
9830 
          self.startDate = iprot.readI64();
9831 
        else:
9832 
          iprot.skip(ftype)
9833 
      elif fid == 3:
9834 
        if ftype == TType.I64:
9835 
          self.endDate = iprot.readI64();
9836 
        else:
9837 
          iprot.skip(ftype)
1845 vikas 9838 
      else:
9839 
        iprot.skip(ftype)
9840 
      iprot.readFieldEnd()
9841 
    iprot.readStructEnd()
9842 
 
9843 
  def write(self, oprot):
9844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9846 
      return
1996 vikas 9847 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9848 
    if self.affiliateId is not None:
1996 vikas 9849 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9850 
      oprot.writeI64(self.affiliateId)
1845 vikas 9851 
      oprot.writeFieldEnd()
3431 rajveer 9852 
    if self.startDate is not None:
3293 vikas 9853 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9854 
      oprot.writeI64(self.startDate)
9855 
      oprot.writeFieldEnd()
3431 rajveer 9856 
    if self.endDate is not None:
3293 vikas 9857 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9858 
      oprot.writeI64(self.endDate)
9859 
      oprot.writeFieldEnd()
1845 vikas 9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
3431 rajveer 9863 
  def validate(self):
9864 
    return
9865 
 
9866 
 
1845 vikas 9867 
  def __repr__(self):
9868 
    L = ['%s=%r' % (key, value)
9869 
      for key, value in self.__dict__.iteritems()]
9870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9871 
 
9872 
  def __eq__(self, other):
9873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9874 
 
9875 
  def __ne__(self, other):
9876 
    return not (self == other)
9877 
 
1996 vikas 9878 
class getTrackLogsByAffiliate_result:
1845 vikas 9879 
  """
9880 
  Attributes:
9881 
   - success
9882 
   - utx
9883 
  """
9884 
 
9885 
  thrift_spec = (
9886 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9887 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9888 
  )
9889 
 
9890 
  def __init__(self, success=None, utx=None,):
9891 
    self.success = success
9892 
    self.utx = utx
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      if fid == 0:
9904 
        if ftype == TType.LIST:
9905 
          self.success = []
11592 amit.gupta 9906 
          (_etype135, _size132) = iprot.readListBegin()
9907 
          for _i136 in xrange(_size132):
9908 
            _elem137 = TrackLog()
9909 
            _elem137.read(iprot)
9910 
            self.success.append(_elem137)
1845 vikas 9911 
          iprot.readListEnd()
9912 
        else:
9913 
          iprot.skip(ftype)
9914 
      elif fid == 1:
9915 
        if ftype == TType.STRUCT:
1996 vikas 9916 
          self.utx = UserAffiliateException()
1845 vikas 9917 
          self.utx.read(iprot)
9918 
        else:
9919 
          iprot.skip(ftype)
9920 
      else:
9921 
        iprot.skip(ftype)
9922 
      iprot.readFieldEnd()
9923 
    iprot.readStructEnd()
9924 
 
9925 
  def write(self, oprot):
9926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9928 
      return
1996 vikas 9929 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 9930 
    if self.success is not None:
1845 vikas 9931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9933 
      for iter138 in self.success:
9934 
        iter138.write(oprot)
1845 vikas 9935 
      oprot.writeListEnd()
9936 
      oprot.writeFieldEnd()
3431 rajveer 9937 
    if self.utx is not None:
1845 vikas 9938 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9939 
      self.utx.write(oprot)
9940 
      oprot.writeFieldEnd()
9941 
    oprot.writeFieldStop()
9942 
    oprot.writeStructEnd()
9943 
 
3431 rajveer 9944 
  def validate(self):
9945 
    return
9946 
 
9947 
 
1845 vikas 9948 
  def __repr__(self):
9949 
    L = ['%s=%r' % (key, value)
9950 
      for key, value in self.__dict__.iteritems()]
9951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9952 
 
9953 
  def __eq__(self, other):
9954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9955 
 
9956 
  def __ne__(self, other):
9957 
    return not (self == other)
9958 
 
9959 
class getTrackLogsByUser_args:
9960 
  """
9961 
  Attributes:
9962 
   - userId
9963 
  """
9964 
 
9965 
  thrift_spec = (
9966 
    None, # 0
9967 
    (1, TType.I64, 'userId', None, None, ), # 1
9968 
  )
9969 
 
9970 
  def __init__(self, userId=None,):
9971 
    self.userId = userId
9972 
 
9973 
  def read(self, iprot):
9974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9976 
      return
9977 
    iprot.readStructBegin()
9978 
    while True:
9979 
      (fname, ftype, fid) = iprot.readFieldBegin()
9980 
      if ftype == TType.STOP:
9981 
        break
9982 
      if fid == 1:
9983 
        if ftype == TType.I64:
9984 
          self.userId = iprot.readI64();
9985 
        else:
9986 
          iprot.skip(ftype)
9987 
      else:
9988 
        iprot.skip(ftype)
9989 
      iprot.readFieldEnd()
9990 
    iprot.readStructEnd()
9991 
 
9992 
  def write(self, oprot):
9993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9995 
      return
9996 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 9997 
    if self.userId is not None:
1845 vikas 9998 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9999 
      oprot.writeI64(self.userId)
10000 
      oprot.writeFieldEnd()
10001 
    oprot.writeFieldStop()
10002 
    oprot.writeStructEnd()
10003 
 
3431 rajveer 10004 
  def validate(self):
10005 
    return
10006 
 
10007 
 
1845 vikas 10008 
  def __repr__(self):
10009 
    L = ['%s=%r' % (key, value)
10010 
      for key, value in self.__dict__.iteritems()]
10011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10012 
 
10013 
  def __eq__(self, other):
10014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10015 
 
10016 
  def __ne__(self, other):
10017 
    return not (self == other)
10018 
 
10019 
class getTrackLogsByUser_result:
10020 
  """
10021 
  Attributes:
10022 
   - success
10023 
   - utx
10024 
  """
10025 
 
10026 
  thrift_spec = (
10027 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10028 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10029 
  )
10030 
 
10031 
  def __init__(self, success=None, utx=None,):
10032 
    self.success = success
10033 
    self.utx = utx
10034 
 
10035 
  def read(self, iprot):
10036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10038 
      return
10039 
    iprot.readStructBegin()
10040 
    while True:
10041 
      (fname, ftype, fid) = iprot.readFieldBegin()
10042 
      if ftype == TType.STOP:
10043 
        break
10044 
      if fid == 0:
10045 
        if ftype == TType.LIST:
10046 
          self.success = []
11592 amit.gupta 10047 
          (_etype142, _size139) = iprot.readListBegin()
10048 
          for _i143 in xrange(_size139):
10049 
            _elem144 = TrackLog()
10050 
            _elem144.read(iprot)
10051 
            self.success.append(_elem144)
1845 vikas 10052 
          iprot.readListEnd()
10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      elif fid == 1:
10056 
        if ftype == TType.STRUCT:
1996 vikas 10057 
          self.utx = UserAffiliateException()
1845 vikas 10058 
          self.utx.read(iprot)
10059 
        else:
10060 
          iprot.skip(ftype)
10061 
      else:
10062 
        iprot.skip(ftype)
10063 
      iprot.readFieldEnd()
10064 
    iprot.readStructEnd()
10065 
 
10066 
  def write(self, oprot):
10067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10069 
      return
10070 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10071 
    if self.success is not None:
1845 vikas 10072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10074 
      for iter145 in self.success:
10075 
        iter145.write(oprot)
1845 vikas 10076 
      oprot.writeListEnd()
10077 
      oprot.writeFieldEnd()
3431 rajveer 10078 
    if self.utx is not None:
1845 vikas 10079 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10080 
      self.utx.write(oprot)
10081 
      oprot.writeFieldEnd()
10082 
    oprot.writeFieldStop()
10083 
    oprot.writeStructEnd()
10084 
 
3431 rajveer 10085 
  def validate(self):
10086 
    return
10087 
 
10088 
 
1845 vikas 10089 
  def __repr__(self):
10090 
    L = ['%s=%r' % (key, value)
10091 
      for key, value in self.__dict__.iteritems()]
10092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10093 
 
10094 
  def __eq__(self, other):
10095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10096 
 
10097 
  def __ne__(self, other):
10098 
    return not (self == other)
10099 
 
10100 
class getTrackLogs_args:
10101 
  """
10102 
  Attributes:
10103 
   - userId
10104 
   - event
10105 
   - url
10106 
  """
10107 
 
10108 
  thrift_spec = (
10109 
    None, # 0
1996 vikas 10110 
    (1, TType.I64, 'userId', None, None, ), # 1
10111 
    (2, TType.STRING, 'event', None, None, ), # 2
10112 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10113 
  )
10114 
 
1996 vikas 10115 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10116 
    self.userId = userId
10117 
    self.event = event
10118 
    self.url = url
10119 
 
10120 
  def read(self, iprot):
10121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10123 
      return
10124 
    iprot.readStructBegin()
10125 
    while True:
10126 
      (fname, ftype, fid) = iprot.readFieldBegin()
10127 
      if ftype == TType.STOP:
10128 
        break
10129 
      if fid == 1:
10130 
        if ftype == TType.I64:
1996 vikas 10131 
          self.userId = iprot.readI64();
1845 vikas 10132 
        else:
10133 
          iprot.skip(ftype)
10134 
      elif fid == 2:
10135 
        if ftype == TType.STRING:
10136 
          self.event = iprot.readString();
10137 
        else:
10138 
          iprot.skip(ftype)
1996 vikas 10139 
      elif fid == 3:
1845 vikas 10140 
        if ftype == TType.STRING:
10141 
          self.url = iprot.readString();
10142 
        else:
10143 
          iprot.skip(ftype)
10144 
      else:
10145 
        iprot.skip(ftype)
10146 
      iprot.readFieldEnd()
10147 
    iprot.readStructEnd()
10148 
 
10149 
  def write(self, oprot):
10150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10152 
      return
10153 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10154 
    if self.userId is not None:
1996 vikas 10155 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10156 
      oprot.writeI64(self.userId)
10157 
      oprot.writeFieldEnd()
3431 rajveer 10158 
    if self.event is not None:
1996 vikas 10159 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10160 
      oprot.writeString(self.event)
10161 
      oprot.writeFieldEnd()
3431 rajveer 10162 
    if self.url is not None:
1996 vikas 10163 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10164 
      oprot.writeString(self.url)
10165 
      oprot.writeFieldEnd()
10166 
    oprot.writeFieldStop()
10167 
    oprot.writeStructEnd()
10168 
 
3431 rajveer 10169 
  def validate(self):
10170 
    return
10171 
 
10172 
 
1845 vikas 10173 
  def __repr__(self):
10174 
    L = ['%s=%r' % (key, value)
10175 
      for key, value in self.__dict__.iteritems()]
10176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10177 
 
10178 
  def __eq__(self, other):
10179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10180 
 
10181 
  def __ne__(self, other):
10182 
    return not (self == other)
10183 
 
10184 
class getTrackLogs_result:
10185 
  """
10186 
  Attributes:
10187 
   - success
10188 
   - utx
10189 
  """
10190 
 
10191 
  thrift_spec = (
10192 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10193 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10194 
  )
10195 
 
10196 
  def __init__(self, success=None, utx=None,):
10197 
    self.success = success
10198 
    self.utx = utx
10199 
 
10200 
  def read(self, iprot):
10201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10203 
      return
10204 
    iprot.readStructBegin()
10205 
    while True:
10206 
      (fname, ftype, fid) = iprot.readFieldBegin()
10207 
      if ftype == TType.STOP:
10208 
        break
10209 
      if fid == 0:
10210 
        if ftype == TType.LIST:
10211 
          self.success = []
11592 amit.gupta 10212 
          (_etype149, _size146) = iprot.readListBegin()
10213 
          for _i150 in xrange(_size146):
10214 
            _elem151 = TrackLog()
10215 
            _elem151.read(iprot)
10216 
            self.success.append(_elem151)
1845 vikas 10217 
          iprot.readListEnd()
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      elif fid == 1:
10221 
        if ftype == TType.STRUCT:
1996 vikas 10222 
          self.utx = UserAffiliateException()
1845 vikas 10223 
          self.utx.read(iprot)
10224 
        else:
10225 
          iprot.skip(ftype)
10226 
      else:
10227 
        iprot.skip(ftype)
10228 
      iprot.readFieldEnd()
10229 
    iprot.readStructEnd()
10230 
 
10231 
  def write(self, oprot):
10232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10234 
      return
10235 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10236 
    if self.success is not None:
1845 vikas 10237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10238 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10239 
      for iter152 in self.success:
10240 
        iter152.write(oprot)
1845 vikas 10241 
      oprot.writeListEnd()
10242 
      oprot.writeFieldEnd()
3431 rajveer 10243 
    if self.utx is not None:
1845 vikas 10244 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10245 
      self.utx.write(oprot)
10246 
      oprot.writeFieldEnd()
10247 
    oprot.writeFieldStop()
10248 
    oprot.writeStructEnd()
10249 
 
3431 rajveer 10250 
  def validate(self):
10251 
    return
10252 
 
10253 
 
1845 vikas 10254 
  def __repr__(self):
10255 
    L = ['%s=%r' % (key, value)
10256 
      for key, value in self.__dict__.iteritems()]
10257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10258 
 
10259 
  def __eq__(self, other):
10260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10261 
 
10262 
  def __ne__(self, other):
10263 
    return not (self == other)
10264 
 
559 chandransh 10265 
class getCurrentCart_args:
94 ashish 10266 
  """
10267 
  Attributes:
559 chandransh 10268 
   - userId
10269 
  """
10270 
 
10271 
  thrift_spec = (
10272 
    None, # 0
10273 
    (1, TType.I64, 'userId', None, None, ), # 1
10274 
  )
10275 
 
10276 
  def __init__(self, userId=None,):
10277 
    self.userId = userId
10278 
 
10279 
  def read(self, iprot):
10280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10282 
      return
10283 
    iprot.readStructBegin()
10284 
    while True:
10285 
      (fname, ftype, fid) = iprot.readFieldBegin()
10286 
      if ftype == TType.STOP:
10287 
        break
10288 
      if fid == 1:
10289 
        if ftype == TType.I64:
10290 
          self.userId = iprot.readI64();
10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      else:
10294 
        iprot.skip(ftype)
10295 
      iprot.readFieldEnd()
10296 
    iprot.readStructEnd()
10297 
 
10298 
  def write(self, oprot):
10299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10301 
      return
10302 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10303 
    if self.userId is not None:
559 chandransh 10304 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10305 
      oprot.writeI64(self.userId)
10306 
      oprot.writeFieldEnd()
10307 
    oprot.writeFieldStop()
10308 
    oprot.writeStructEnd()
10309 
 
3431 rajveer 10310 
  def validate(self):
10311 
    return
10312 
 
10313 
 
559 chandransh 10314 
  def __repr__(self):
10315 
    L = ['%s=%r' % (key, value)
10316 
      for key, value in self.__dict__.iteritems()]
10317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10318 
 
10319 
  def __eq__(self, other):
10320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10321 
 
10322 
  def __ne__(self, other):
10323 
    return not (self == other)
10324 
 
10325 
class getCurrentCart_result:
10326 
  """
10327 
  Attributes:
94 ashish 10328 
   - success
559 chandransh 10329 
   - scx
94 ashish 10330 
  """
10331 
 
10332 
  thrift_spec = (
559 chandransh 10333 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10334 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10335 
  )
10336 
 
559 chandransh 10337 
  def __init__(self, success=None, scx=None,):
94 ashish 10338 
    self.success = success
559 chandransh 10339 
    self.scx = scx
94 ashish 10340 
 
10341 
  def read(self, iprot):
10342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10344 
      return
10345 
    iprot.readStructBegin()
10346 
    while True:
10347 
      (fname, ftype, fid) = iprot.readFieldBegin()
10348 
      if ftype == TType.STOP:
10349 
        break
10350 
      if fid == 0:
559 chandransh 10351 
        if ftype == TType.STRUCT:
10352 
          self.success = Cart()
10353 
          self.success.read(iprot)
94 ashish 10354 
        else:
10355 
          iprot.skip(ftype)
10356 
      elif fid == 1:
10357 
        if ftype == TType.STRUCT:
559 chandransh 10358 
          self.scx = ShoppingCartException()
10359 
          self.scx.read(iprot)
94 ashish 10360 
        else:
10361 
          iprot.skip(ftype)
10362 
      else:
10363 
        iprot.skip(ftype)
10364 
      iprot.readFieldEnd()
10365 
    iprot.readStructEnd()
10366 
 
10367 
  def write(self, oprot):
10368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10370 
      return
559 chandransh 10371 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10372 
    if self.success is not None:
559 chandransh 10373 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10374 
      self.success.write(oprot)
94 ashish 10375 
      oprot.writeFieldEnd()
3431 rajveer 10376 
    if self.scx is not None:
559 chandransh 10377 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10378 
      self.scx.write(oprot)
94 ashish 10379 
      oprot.writeFieldEnd()
10380 
    oprot.writeFieldStop()
10381 
    oprot.writeStructEnd()
10382 
 
3431 rajveer 10383 
  def validate(self):
10384 
    return
10385 
 
10386 
 
94 ashish 10387 
  def __repr__(self):
10388 
    L = ['%s=%r' % (key, value)
10389 
      for key, value in self.__dict__.iteritems()]
10390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10391 
 
10392 
  def __eq__(self, other):
10393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10394 
 
10395 
  def __ne__(self, other):
10396 
    return not (self == other)
10397 
 
559 chandransh 10398 
class getCart_args:
504 rajveer 10399 
  """
10400 
  Attributes:
559 chandransh 10401 
   - cartId
504 rajveer 10402 
  """
10403 
 
10404 
  thrift_spec = (
10405 
    None, # 0
559 chandransh 10406 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10407 
  )
10408 
 
559 chandransh 10409 
  def __init__(self, cartId=None,):
10410 
    self.cartId = cartId
504 rajveer 10411 
 
10412 
  def read(self, iprot):
10413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10415 
      return
10416 
    iprot.readStructBegin()
10417 
    while True:
10418 
      (fname, ftype, fid) = iprot.readFieldBegin()
10419 
      if ftype == TType.STOP:
10420 
        break
10421 
      if fid == 1:
10422 
        if ftype == TType.I64:
559 chandransh 10423 
          self.cartId = iprot.readI64();
504 rajveer 10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      else:
10427 
        iprot.skip(ftype)
10428 
      iprot.readFieldEnd()
10429 
    iprot.readStructEnd()
10430 
 
10431 
  def write(self, oprot):
10432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10434 
      return
559 chandransh 10435 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10436 
    if self.cartId is not None:
559 chandransh 10437 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10438 
      oprot.writeI64(self.cartId)
504 rajveer 10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
3431 rajveer 10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
504 rajveer 10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
559 chandransh 10458 
class getCart_result:
504 rajveer 10459 
  """
10460 
  Attributes:
10461 
   - success
559 chandransh 10462 
   - scx
504 rajveer 10463 
  """
10464 
 
10465 
  thrift_spec = (
559 chandransh 10466 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10467 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10468 
  )
10469 
 
559 chandransh 10470 
  def __init__(self, success=None, scx=None,):
504 rajveer 10471 
    self.success = success
559 chandransh 10472 
    self.scx = scx
504 rajveer 10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 0:
559 chandransh 10484 
        if ftype == TType.STRUCT:
10485 
          self.success = Cart()
10486 
          self.success.read(iprot)
504 rajveer 10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 1:
10490 
        if ftype == TType.STRUCT:
559 chandransh 10491 
          self.scx = ShoppingCartException()
10492 
          self.scx.read(iprot)
504 rajveer 10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      else:
10496 
        iprot.skip(ftype)
10497 
      iprot.readFieldEnd()
10498 
    iprot.readStructEnd()
10499 
 
10500 
  def write(self, oprot):
10501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10503 
      return
559 chandransh 10504 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10505 
    if self.success is not None:
559 chandransh 10506 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10507 
      self.success.write(oprot)
504 rajveer 10508 
      oprot.writeFieldEnd()
3431 rajveer 10509 
    if self.scx is not None:
559 chandransh 10510 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10511 
      self.scx.write(oprot)
504 rajveer 10512 
      oprot.writeFieldEnd()
10513 
    oprot.writeFieldStop()
10514 
    oprot.writeStructEnd()
10515 
 
3431 rajveer 10516 
  def validate(self):
10517 
    return
10518 
 
10519 
 
504 rajveer 10520 
  def __repr__(self):
10521 
    L = ['%s=%r' % (key, value)
10522 
      for key, value in self.__dict__.iteritems()]
10523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10524 
 
10525 
  def __eq__(self, other):
10526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10527 
 
10528 
  def __ne__(self, other):
10529 
    return not (self == other)
10530 
 
559 chandransh 10531 
class getCartsByTime_args:
10532 
  """
10533 
  Attributes:
10534 
   - from_time
10535 
   - to_time
10536 
   - status
10537 
  """
10538 
 
10539 
  thrift_spec = (
10540 
    None, # 0
10541 
    (1, TType.I64, 'from_time', None, None, ), # 1
10542 
    (2, TType.I64, 'to_time', None, None, ), # 2
10543 
    (3, TType.I32, 'status', None, None, ), # 3
10544 
  )
10545 
 
10546 
  def __init__(self, from_time=None, to_time=None, status=None,):
10547 
    self.from_time = from_time
10548 
    self.to_time = to_time
10549 
    self.status = status
10550 
 
10551 
  def read(self, iprot):
10552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10554 
      return
10555 
    iprot.readStructBegin()
10556 
    while True:
10557 
      (fname, ftype, fid) = iprot.readFieldBegin()
10558 
      if ftype == TType.STOP:
10559 
        break
10560 
      if fid == 1:
94 ashish 10561 
        if ftype == TType.I64:
559 chandransh 10562 
          self.from_time = iprot.readI64();
94 ashish 10563 
        else:
10564 
          iprot.skip(ftype)
122 ashish 10565 
      elif fid == 2:
559 chandransh 10566 
        if ftype == TType.I64:
10567 
          self.to_time = iprot.readI64();
122 ashish 10568 
        else:
10569 
          iprot.skip(ftype)
559 chandransh 10570 
      elif fid == 3:
10571 
        if ftype == TType.I32:
10572 
          self.status = iprot.readI32();
10573 
        else:
10574 
          iprot.skip(ftype)
94 ashish 10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
559 chandransh 10584 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10585 
    if self.from_time is not None:
559 chandransh 10586 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10587 
      oprot.writeI64(self.from_time)
94 ashish 10588 
      oprot.writeFieldEnd()
3431 rajveer 10589 
    if self.to_time is not None:
559 chandransh 10590 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10591 
      oprot.writeI64(self.to_time)
122 ashish 10592 
      oprot.writeFieldEnd()
3431 rajveer 10593 
    if self.status is not None:
559 chandransh 10594 
      oprot.writeFieldBegin('status', TType.I32, 3)
10595 
      oprot.writeI32(self.status)
10596 
      oprot.writeFieldEnd()
94 ashish 10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
3431 rajveer 10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
94 ashish 10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
559 chandransh 10615 
class getCartsByTime_result:
94 ashish 10616 
  """
10617 
  Attributes:
10618 
   - success
559 chandransh 10619 
   - scx
94 ashish 10620 
  """
10621 
 
10622 
  thrift_spec = (
559 chandransh 10623 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10624 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10625 
  )
10626 
 
559 chandransh 10627 
  def __init__(self, success=None, scx=None,):
94 ashish 10628 
    self.success = success
559 chandransh 10629 
    self.scx = scx
94 ashish 10630 
 
10631 
  def read(self, iprot):
10632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10634 
      return
10635 
    iprot.readStructBegin()
10636 
    while True:
10637 
      (fname, ftype, fid) = iprot.readFieldBegin()
10638 
      if ftype == TType.STOP:
10639 
        break
10640 
      if fid == 0:
559 chandransh 10641 
        if ftype == TType.LIST:
10642 
          self.success = []
11592 amit.gupta 10643 
          (_etype156, _size153) = iprot.readListBegin()
10644 
          for _i157 in xrange(_size153):
10645 
            _elem158 = Cart()
10646 
            _elem158.read(iprot)
10647 
            self.success.append(_elem158)
559 chandransh 10648 
          iprot.readListEnd()
94 ashish 10649 
        else:
10650 
          iprot.skip(ftype)
10651 
      elif fid == 1:
10652 
        if ftype == TType.STRUCT:
559 chandransh 10653 
          self.scx = ShoppingCartException()
10654 
          self.scx.read(iprot)
94 ashish 10655 
        else:
10656 
          iprot.skip(ftype)
10657 
      else:
10658 
        iprot.skip(ftype)
10659 
      iprot.readFieldEnd()
10660 
    iprot.readStructEnd()
10661 
 
10662 
  def write(self, oprot):
10663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10665 
      return
559 chandransh 10666 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10667 
    if self.success is not None:
559 chandransh 10668 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10669 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10670 
      for iter159 in self.success:
10671 
        iter159.write(oprot)
559 chandransh 10672 
      oprot.writeListEnd()
94 ashish 10673 
      oprot.writeFieldEnd()
3431 rajveer 10674 
    if self.scx is not None:
559 chandransh 10675 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10676 
      self.scx.write(oprot)
94 ashish 10677 
      oprot.writeFieldEnd()
10678 
    oprot.writeFieldStop()
10679 
    oprot.writeStructEnd()
10680 
 
3431 rajveer 10681 
  def validate(self):
10682 
    return
10683 
 
10684 
 
94 ashish 10685 
  def __repr__(self):
10686 
    L = ['%s=%r' % (key, value)
10687 
      for key, value in self.__dict__.iteritems()]
10688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10689 
 
10690 
  def __eq__(self, other):
10691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10692 
 
10693 
  def __ne__(self, other):
10694 
    return not (self == other)
10695 
 
559 chandransh 10696 
class addItemToCart_args:
10697 
  """
10698 
  Attributes:
10699 
   - cartId
10700 
   - itemId
10701 
   - quantity
3557 rajveer 10702 
   - sourceId
559 chandransh 10703 
  """
10704 
 
10705 
  thrift_spec = (
10706 
    None, # 0
10707 
    (1, TType.I64, 'cartId', None, None, ), # 1
10708 
    (2, TType.I64, 'itemId', None, None, ), # 2
10709 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10710 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10711 
  )
10712 
 
3557 rajveer 10713 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10714 
    self.cartId = cartId
10715 
    self.itemId = itemId
10716 
    self.quantity = quantity
3557 rajveer 10717 
    self.sourceId = sourceId
559 chandransh 10718 
 
10719 
  def read(self, iprot):
10720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10722 
      return
10723 
    iprot.readStructBegin()
10724 
    while True:
10725 
      (fname, ftype, fid) = iprot.readFieldBegin()
10726 
      if ftype == TType.STOP:
10727 
        break
10728 
      if fid == 1:
10729 
        if ftype == TType.I64:
10730 
          self.cartId = iprot.readI64();
10731 
        else:
10732 
          iprot.skip(ftype)
10733 
      elif fid == 2:
10734 
        if ftype == TType.I64:
10735 
          self.itemId = iprot.readI64();
10736 
        else:
10737 
          iprot.skip(ftype)
10738 
      elif fid == 3:
10739 
        if ftype == TType.I64:
10740 
          self.quantity = iprot.readI64();
10741 
        else:
10742 
          iprot.skip(ftype)
3557 rajveer 10743 
      elif fid == 4:
10744 
        if ftype == TType.I64:
10745 
          self.sourceId = iprot.readI64();
10746 
        else:
10747 
          iprot.skip(ftype)
559 chandransh 10748 
      else:
10749 
        iprot.skip(ftype)
10750 
      iprot.readFieldEnd()
10751 
    iprot.readStructEnd()
10752 
 
10753 
  def write(self, oprot):
10754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10756 
      return
10757 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10758 
    if self.cartId is not None:
559 chandransh 10759 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10760 
      oprot.writeI64(self.cartId)
10761 
      oprot.writeFieldEnd()
3431 rajveer 10762 
    if self.itemId is not None:
559 chandransh 10763 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10764 
      oprot.writeI64(self.itemId)
10765 
      oprot.writeFieldEnd()
3431 rajveer 10766 
    if self.quantity is not None:
559 chandransh 10767 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10768 
      oprot.writeI64(self.quantity)
10769 
      oprot.writeFieldEnd()
3557 rajveer 10770 
    if self.sourceId is not None:
10771 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10772 
      oprot.writeI64(self.sourceId)
10773 
      oprot.writeFieldEnd()
559 chandransh 10774 
    oprot.writeFieldStop()
10775 
    oprot.writeStructEnd()
10776 
 
3431 rajveer 10777 
  def validate(self):
10778 
    return
10779 
 
10780 
 
559 chandransh 10781 
  def __repr__(self):
10782 
    L = ['%s=%r' % (key, value)
10783 
      for key, value in self.__dict__.iteritems()]
10784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10785 
 
10786 
  def __eq__(self, other):
10787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10788 
 
10789 
  def __ne__(self, other):
10790 
    return not (self == other)
10791 
 
10792 
class addItemToCart_result:
10793 
  """
10794 
  Attributes:
2035 rajveer 10795 
   - success
559 chandransh 10796 
   - scx
10797 
  """
10798 
 
10799 
  thrift_spec = (
2035 rajveer 10800 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10801 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10802 
  )
10803 
 
2035 rajveer 10804 
  def __init__(self, success=None, scx=None,):
10805 
    self.success = success
559 chandransh 10806 
    self.scx = scx
10807 
 
10808 
  def read(self, iprot):
10809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10811 
      return
10812 
    iprot.readStructBegin()
10813 
    while True:
10814 
      (fname, ftype, fid) = iprot.readFieldBegin()
10815 
      if ftype == TType.STOP:
10816 
        break
2035 rajveer 10817 
      if fid == 0:
10818 
        if ftype == TType.STRING:
10819 
          self.success = iprot.readString();
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      elif fid == 1:
559 chandransh 10823 
        if ftype == TType.STRUCT:
10824 
          self.scx = ShoppingCartException()
10825 
          self.scx.read(iprot)
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      else:
10829 
        iprot.skip(ftype)
10830 
      iprot.readFieldEnd()
10831 
    iprot.readStructEnd()
10832 
 
10833 
  def write(self, oprot):
10834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10836 
      return
10837 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10838 
    if self.success is not None:
2035 rajveer 10839 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10840 
      oprot.writeString(self.success)
10841 
      oprot.writeFieldEnd()
3431 rajveer 10842 
    if self.scx is not None:
559 chandransh 10843 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10844 
      self.scx.write(oprot)
10845 
      oprot.writeFieldEnd()
10846 
    oprot.writeFieldStop()
10847 
    oprot.writeStructEnd()
10848 
 
3431 rajveer 10849 
  def validate(self):
10850 
    return
10851 
 
10852 
 
559 chandransh 10853 
  def __repr__(self):
10854 
    L = ['%s=%r' % (key, value)
10855 
      for key, value in self.__dict__.iteritems()]
10856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10857 
 
10858 
  def __eq__(self, other):
10859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10860 
 
10861 
  def __ne__(self, other):
10862 
    return not (self == other)
10863 
 
10864 
class deleteItemFromCart_args:
10865 
  """
10866 
  Attributes:
10867 
   - cartId
10868 
   - itemId
10869 
  """
10870 
 
10871 
  thrift_spec = (
10872 
    None, # 0
10873 
    (1, TType.I64, 'cartId', None, None, ), # 1
10874 
    (2, TType.I64, 'itemId', None, None, ), # 2
10875 
  )
10876 
 
10877 
  def __init__(self, cartId=None, itemId=None,):
10878 
    self.cartId = cartId
10879 
    self.itemId = itemId
10880 
 
10881 
  def read(self, iprot):
10882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10884 
      return
10885 
    iprot.readStructBegin()
10886 
    while True:
10887 
      (fname, ftype, fid) = iprot.readFieldBegin()
10888 
      if ftype == TType.STOP:
10889 
        break
10890 
      if fid == 1:
10891 
        if ftype == TType.I64:
10892 
          self.cartId = iprot.readI64();
10893 
        else:
10894 
          iprot.skip(ftype)
10895 
      elif fid == 2:
10896 
        if ftype == TType.I64:
10897 
          self.itemId = iprot.readI64();
10898 
        else:
10899 
          iprot.skip(ftype)
10900 
      else:
10901 
        iprot.skip(ftype)
10902 
      iprot.readFieldEnd()
10903 
    iprot.readStructEnd()
10904 
 
10905 
  def write(self, oprot):
10906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10908 
      return
10909 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 10910 
    if self.cartId is not None:
559 chandransh 10911 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10912 
      oprot.writeI64(self.cartId)
10913 
      oprot.writeFieldEnd()
3431 rajveer 10914 
    if self.itemId is not None:
559 chandransh 10915 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10916 
      oprot.writeI64(self.itemId)
10917 
      oprot.writeFieldEnd()
10918 
    oprot.writeFieldStop()
10919 
    oprot.writeStructEnd()
10920 
 
3431 rajveer 10921 
  def validate(self):
10922 
    return
10923 
 
10924 
 
559 chandransh 10925 
  def __repr__(self):
10926 
    L = ['%s=%r' % (key, value)
10927 
      for key, value in self.__dict__.iteritems()]
10928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10929 
 
10930 
  def __eq__(self, other):
10931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10932 
 
10933 
  def __ne__(self, other):
10934 
    return not (self == other)
10935 
 
10936 
class deleteItemFromCart_result:
10937 
  """
10938 
  Attributes:
10939 
   - scx
10940 
  """
10941 
 
10942 
  thrift_spec = (
10943 
    None, # 0
10944 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10945 
  )
10946 
 
10947 
  def __init__(self, scx=None,):
10948 
    self.scx = scx
10949 
 
10950 
  def read(self, iprot):
10951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10953 
      return
10954 
    iprot.readStructBegin()
10955 
    while True:
10956 
      (fname, ftype, fid) = iprot.readFieldBegin()
10957 
      if ftype == TType.STOP:
10958 
        break
10959 
      if fid == 1:
10960 
        if ftype == TType.STRUCT:
10961 
          self.scx = ShoppingCartException()
10962 
          self.scx.read(iprot)
10963 
        else:
10964 
          iprot.skip(ftype)
10965 
      else:
10966 
        iprot.skip(ftype)
10967 
      iprot.readFieldEnd()
10968 
    iprot.readStructEnd()
10969 
 
10970 
  def write(self, oprot):
10971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10973 
      return
10974 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 10975 
    if self.scx is not None:
559 chandransh 10976 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10977 
      self.scx.write(oprot)
10978 
      oprot.writeFieldEnd()
10979 
    oprot.writeFieldStop()
10980 
    oprot.writeStructEnd()
10981 
 
3431 rajveer 10982 
  def validate(self):
10983 
    return
10984 
 
10985 
 
559 chandransh 10986 
  def __repr__(self):
10987 
    L = ['%s=%r' % (key, value)
10988 
      for key, value in self.__dict__.iteritems()]
10989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10990 
 
10991 
  def __eq__(self, other):
10992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10993 
 
10994 
  def __ne__(self, other):
10995 
    return not (self == other)
10996 
 
10997 
class addAddressToCart_args:
10998 
  """
10999 
  Attributes:
11000 
   - cartId
11001 
   - addressId
11002 
  """
11003 
 
11004 
  thrift_spec = (
11005 
    None, # 0
11006 
    (1, TType.I64, 'cartId', None, None, ), # 1
11007 
    (2, TType.I64, 'addressId', None, None, ), # 2
11008 
  )
11009 
 
11010 
  def __init__(self, cartId=None, addressId=None,):
11011 
    self.cartId = cartId
11012 
    self.addressId = addressId
11013 
 
11014 
  def read(self, iprot):
11015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11017 
      return
11018 
    iprot.readStructBegin()
11019 
    while True:
11020 
      (fname, ftype, fid) = iprot.readFieldBegin()
11021 
      if ftype == TType.STOP:
11022 
        break
11023 
      if fid == 1:
11024 
        if ftype == TType.I64:
11025 
          self.cartId = iprot.readI64();
11026 
        else:
11027 
          iprot.skip(ftype)
11028 
      elif fid == 2:
11029 
        if ftype == TType.I64:
11030 
          self.addressId = iprot.readI64();
11031 
        else:
11032 
          iprot.skip(ftype)
11033 
      else:
11034 
        iprot.skip(ftype)
11035 
      iprot.readFieldEnd()
11036 
    iprot.readStructEnd()
11037 
 
11038 
  def write(self, oprot):
11039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11041 
      return
11042 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11043 
    if self.cartId is not None:
559 chandransh 11044 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11045 
      oprot.writeI64(self.cartId)
11046 
      oprot.writeFieldEnd()
3431 rajveer 11047 
    if self.addressId is not None:
559 chandransh 11048 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11049 
      oprot.writeI64(self.addressId)
11050 
      oprot.writeFieldEnd()
11051 
    oprot.writeFieldStop()
11052 
    oprot.writeStructEnd()
11053 
 
3431 rajveer 11054 
  def validate(self):
11055 
    return
11056 
 
11057 
 
559 chandransh 11058 
  def __repr__(self):
11059 
    L = ['%s=%r' % (key, value)
11060 
      for key, value in self.__dict__.iteritems()]
11061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11062 
 
11063 
  def __eq__(self, other):
11064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11065 
 
11066 
  def __ne__(self, other):
11067 
    return not (self == other)
11068 
 
11069 
class addAddressToCart_result:
575 chandransh 11070 
  """
11071 
  Attributes:
11072 
   - scx
11073 
  """
559 chandransh 11074 
 
11075 
  thrift_spec = (
575 chandransh 11076 
    None, # 0
11077 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11078 
  )
11079 
 
575 chandransh 11080 
  def __init__(self, scx=None,):
11081 
    self.scx = scx
11082 
 
559 chandransh 11083 
  def read(self, iprot):
11084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11086 
      return
11087 
    iprot.readStructBegin()
11088 
    while True:
11089 
      (fname, ftype, fid) = iprot.readFieldBegin()
11090 
      if ftype == TType.STOP:
11091 
        break
575 chandransh 11092 
      if fid == 1:
11093 
        if ftype == TType.STRUCT:
11094 
          self.scx = ShoppingCartException()
11095 
          self.scx.read(iprot)
11096 
        else:
11097 
          iprot.skip(ftype)
559 chandransh 11098 
      else:
11099 
        iprot.skip(ftype)
11100 
      iprot.readFieldEnd()
11101 
    iprot.readStructEnd()
11102 
 
11103 
  def write(self, oprot):
11104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11106 
      return
11107 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11108 
    if self.scx is not None:
575 chandransh 11109 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11110 
      self.scx.write(oprot)
11111 
      oprot.writeFieldEnd()
559 chandransh 11112 
    oprot.writeFieldStop()
11113 
    oprot.writeStructEnd()
11114 
 
3431 rajveer 11115 
  def validate(self):
11116 
    return
11117 
 
11118 
 
559 chandransh 11119 
  def __repr__(self):
11120 
    L = ['%s=%r' % (key, value)
11121 
      for key, value in self.__dict__.iteritems()]
11122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11123 
 
11124 
  def __eq__(self, other):
11125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11126 
 
11127 
  def __ne__(self, other):
11128 
    return not (self == other)
11129 
 
5553 rajveer 11130 
class addStoreToCart_args:
11131 
  """
11132 
  Attributes:
11133 
   - cartId
11134 
   - storeId
11135 
  """
11136 
 
11137 
  thrift_spec = (
11138 
    None, # 0
11139 
    (1, TType.I64, 'cartId', None, None, ), # 1
11140 
    (2, TType.I64, 'storeId', None, None, ), # 2
11141 
  )
11142 
 
11143 
  def __init__(self, cartId=None, storeId=None,):
11144 
    self.cartId = cartId
11145 
    self.storeId = storeId
11146 
 
11147 
  def read(self, iprot):
11148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11150 
      return
11151 
    iprot.readStructBegin()
11152 
    while True:
11153 
      (fname, ftype, fid) = iprot.readFieldBegin()
11154 
      if ftype == TType.STOP:
11155 
        break
11156 
      if fid == 1:
11157 
        if ftype == TType.I64:
11158 
          self.cartId = iprot.readI64();
11159 
        else:
11160 
          iprot.skip(ftype)
11161 
      elif fid == 2:
11162 
        if ftype == TType.I64:
11163 
          self.storeId = iprot.readI64();
11164 
        else:
11165 
          iprot.skip(ftype)
11166 
      else:
11167 
        iprot.skip(ftype)
11168 
      iprot.readFieldEnd()
11169 
    iprot.readStructEnd()
11170 
 
11171 
  def write(self, oprot):
11172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11174 
      return
11175 
    oprot.writeStructBegin('addStoreToCart_args')
11176 
    if self.cartId is not None:
11177 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11178 
      oprot.writeI64(self.cartId)
11179 
      oprot.writeFieldEnd()
11180 
    if self.storeId is not None:
11181 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11182 
      oprot.writeI64(self.storeId)
11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
11187 
  def validate(self):
11188 
    return
11189 
 
11190 
 
11191 
  def __repr__(self):
11192 
    L = ['%s=%r' % (key, value)
11193 
      for key, value in self.__dict__.iteritems()]
11194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11195 
 
11196 
  def __eq__(self, other):
11197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11198 
 
11199 
  def __ne__(self, other):
11200 
    return not (self == other)
11201 
 
11202 
class addStoreToCart_result:
11203 
  """
11204 
  Attributes:
11205 
   - scx
11206 
  """
11207 
 
11208 
  thrift_spec = (
11209 
    None, # 0
11210 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11211 
  )
11212 
 
11213 
  def __init__(self, scx=None,):
11214 
    self.scx = scx
11215 
 
11216 
  def read(self, iprot):
11217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11219 
      return
11220 
    iprot.readStructBegin()
11221 
    while True:
11222 
      (fname, ftype, fid) = iprot.readFieldBegin()
11223 
      if ftype == TType.STOP:
11224 
        break
11225 
      if fid == 1:
11226 
        if ftype == TType.STRUCT:
11227 
          self.scx = ShoppingCartException()
11228 
          self.scx.read(iprot)
11229 
        else:
11230 
          iprot.skip(ftype)
11231 
      else:
11232 
        iprot.skip(ftype)
11233 
      iprot.readFieldEnd()
11234 
    iprot.readStructEnd()
11235 
 
11236 
  def write(self, oprot):
11237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11239 
      return
11240 
    oprot.writeStructBegin('addStoreToCart_result')
11241 
    if self.scx is not None:
11242 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11243 
      self.scx.write(oprot)
11244 
      oprot.writeFieldEnd()
11245 
    oprot.writeFieldStop()
11246 
    oprot.writeStructEnd()
11247 
 
11248 
  def validate(self):
11249 
    return
11250 
 
11251 
 
11252 
  def __repr__(self):
11253 
    L = ['%s=%r' % (key, value)
11254 
      for key, value in self.__dict__.iteritems()]
11255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11256 
 
11257 
  def __eq__(self, other):
11258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11259 
 
11260 
  def __ne__(self, other):
11261 
    return not (self == other)
11262 
 
1976 varun.gupt 11263 
class applyCouponToCart_args:
11264 
  """
11265 
  Attributes:
6922 anupam.sin 11266 
   - cart
1976 varun.gupt 11267 
   - couponCode
11268 
  """
11269 
 
11270 
  thrift_spec = (
11271 
    None, # 0
6922 anupam.sin 11272 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11273 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11274 
  )
11275 
 
6922 anupam.sin 11276 
  def __init__(self, cart=None, couponCode=None,):
11277 
    self.cart = cart
1976 varun.gupt 11278 
    self.couponCode = couponCode
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 == 1:
6922 anupam.sin 11290 
        if ftype == TType.STRUCT:
11291 
          self.cart = Cart()
11292 
          self.cart.read(iprot)
1976 varun.gupt 11293 
        else:
11294 
          iprot.skip(ftype)
11295 
      elif fid == 2:
11296 
        if ftype == TType.STRING:
11297 
          self.couponCode = iprot.readString();
11298 
        else:
11299 
          iprot.skip(ftype)
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
11309 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11310 
    if self.cart is not None:
11311 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11312 
      self.cart.write(oprot)
1976 varun.gupt 11313 
      oprot.writeFieldEnd()
3431 rajveer 11314 
    if self.couponCode is not None:
1976 varun.gupt 11315 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11316 
      oprot.writeString(self.couponCode)
11317 
      oprot.writeFieldEnd()
11318 
    oprot.writeFieldStop()
11319 
    oprot.writeStructEnd()
11320 
 
3431 rajveer 11321 
  def validate(self):
11322 
    return
11323 
 
11324 
 
1976 varun.gupt 11325 
  def __repr__(self):
11326 
    L = ['%s=%r' % (key, value)
11327 
      for key, value in self.__dict__.iteritems()]
11328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11329 
 
11330 
  def __eq__(self, other):
11331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11332 
 
11333 
  def __ne__(self, other):
11334 
    return not (self == other)
11335 
 
11336 
class applyCouponToCart_result:
11337 
  """
11338 
  Attributes:
11339 
   - scx
11340 
  """
11341 
 
11342 
  thrift_spec = (
11343 
    None, # 0
11344 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11345 
  )
11346 
 
11347 
  def __init__(self, scx=None,):
11348 
    self.scx = scx
11349 
 
11350 
  def read(self, iprot):
11351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11353 
      return
11354 
    iprot.readStructBegin()
11355 
    while True:
11356 
      (fname, ftype, fid) = iprot.readFieldBegin()
11357 
      if ftype == TType.STOP:
11358 
        break
11359 
      if fid == 1:
11360 
        if ftype == TType.STRUCT:
11361 
          self.scx = ShoppingCartException()
11362 
          self.scx.read(iprot)
11363 
        else:
11364 
          iprot.skip(ftype)
11365 
      else:
11366 
        iprot.skip(ftype)
11367 
      iprot.readFieldEnd()
11368 
    iprot.readStructEnd()
11369 
 
11370 
  def write(self, oprot):
11371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11373 
      return
11374 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11375 
    if self.scx is not None:
1976 varun.gupt 11376 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11377 
      self.scx.write(oprot)
11378 
      oprot.writeFieldEnd()
11379 
    oprot.writeFieldStop()
11380 
    oprot.writeStructEnd()
11381 
 
3431 rajveer 11382 
  def validate(self):
11383 
    return
11384 
 
11385 
 
1976 varun.gupt 11386 
  def __repr__(self):
11387 
    L = ['%s=%r' % (key, value)
11388 
      for key, value in self.__dict__.iteritems()]
11389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11390 
 
11391 
  def __eq__(self, other):
11392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11393 
 
11394 
  def __ne__(self, other):
11395 
    return not (self == other)
11396 
 
11397 
class removeCoupon_args:
11398 
  """
11399 
  Attributes:
11400 
   - cartId
11401 
  """
11402 
 
11403 
  thrift_spec = (
11404 
    None, # 0
11405 
    (1, TType.I64, 'cartId', None, None, ), # 1
11406 
  )
11407 
 
11408 
  def __init__(self, cartId=None,):
11409 
    self.cartId = cartId
11410 
 
11411 
  def read(self, iprot):
11412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11414 
      return
11415 
    iprot.readStructBegin()
11416 
    while True:
11417 
      (fname, ftype, fid) = iprot.readFieldBegin()
11418 
      if ftype == TType.STOP:
11419 
        break
11420 
      if fid == 1:
11421 
        if ftype == TType.I64:
11422 
          self.cartId = iprot.readI64();
11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      else:
11426 
        iprot.skip(ftype)
11427 
      iprot.readFieldEnd()
11428 
    iprot.readStructEnd()
11429 
 
11430 
  def write(self, oprot):
11431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11433 
      return
11434 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11435 
    if self.cartId is not None:
1976 varun.gupt 11436 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11437 
      oprot.writeI64(self.cartId)
11438 
      oprot.writeFieldEnd()
11439 
    oprot.writeFieldStop()
11440 
    oprot.writeStructEnd()
11441 
 
3431 rajveer 11442 
  def validate(self):
11443 
    return
11444 
 
11445 
 
1976 varun.gupt 11446 
  def __repr__(self):
11447 
    L = ['%s=%r' % (key, value)
11448 
      for key, value in self.__dict__.iteritems()]
11449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11450 
 
11451 
  def __eq__(self, other):
11452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11453 
 
11454 
  def __ne__(self, other):
11455 
    return not (self == other)
11456 
 
11457 
class removeCoupon_result:
11458 
  """
11459 
  Attributes:
11460 
   - scx
11461 
  """
11462 
 
11463 
  thrift_spec = (
11464 
    None, # 0
11465 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11466 
  )
11467 
 
11468 
  def __init__(self, scx=None,):
11469 
    self.scx = scx
11470 
 
11471 
  def read(self, iprot):
11472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11474 
      return
11475 
    iprot.readStructBegin()
11476 
    while True:
11477 
      (fname, ftype, fid) = iprot.readFieldBegin()
11478 
      if ftype == TType.STOP:
11479 
        break
11480 
      if fid == 1:
11481 
        if ftype == TType.STRUCT:
11482 
          self.scx = ShoppingCartException()
11483 
          self.scx.read(iprot)
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      else:
11487 
        iprot.skip(ftype)
11488 
      iprot.readFieldEnd()
11489 
    iprot.readStructEnd()
11490 
 
11491 
  def write(self, oprot):
11492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11494 
      return
11495 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11496 
    if self.scx is not None:
1976 varun.gupt 11497 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11498 
      self.scx.write(oprot)
11499 
      oprot.writeFieldEnd()
11500 
    oprot.writeFieldStop()
11501 
    oprot.writeStructEnd()
11502 
 
3431 rajveer 11503 
  def validate(self):
11504 
    return
11505 
 
11506 
 
1976 varun.gupt 11507 
  def __repr__(self):
11508 
    L = ['%s=%r' % (key, value)
11509 
      for key, value in self.__dict__.iteritems()]
11510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11511 
 
11512 
  def __eq__(self, other):
11513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11514 
 
11515 
  def __ne__(self, other):
11516 
    return not (self == other)
11517 
 
3554 varun.gupt 11518 
class deleteDiscountsFromCart_args:
11519 
  """
11520 
  Attributes:
11521 
   - cartId
11522 
  """
11523 
 
11524 
  thrift_spec = (
11525 
    None, # 0
11526 
    (1, TType.I64, 'cartId', None, None, ), # 1
11527 
  )
11528 
 
11529 
  def __init__(self, cartId=None,):
11530 
    self.cartId = cartId
11531 
 
11532 
  def read(self, iprot):
11533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11535 
      return
11536 
    iprot.readStructBegin()
11537 
    while True:
11538 
      (fname, ftype, fid) = iprot.readFieldBegin()
11539 
      if ftype == TType.STOP:
11540 
        break
11541 
      if fid == 1:
11542 
        if ftype == TType.I64:
11543 
          self.cartId = iprot.readI64();
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      else:
11547 
        iprot.skip(ftype)
11548 
      iprot.readFieldEnd()
11549 
    iprot.readStructEnd()
11550 
 
11551 
  def write(self, oprot):
11552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11554 
      return
11555 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11556 
    if self.cartId is not None:
11557 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11558 
      oprot.writeI64(self.cartId)
11559 
      oprot.writeFieldEnd()
11560 
    oprot.writeFieldStop()
11561 
    oprot.writeStructEnd()
11562 
 
11563 
  def validate(self):
11564 
    return
11565 
 
11566 
 
11567 
  def __repr__(self):
11568 
    L = ['%s=%r' % (key, value)
11569 
      for key, value in self.__dict__.iteritems()]
11570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11571 
 
11572 
  def __eq__(self, other):
11573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11574 
 
11575 
  def __ne__(self, other):
11576 
    return not (self == other)
11577 
 
11578 
class deleteDiscountsFromCart_result:
11579 
  """
11580 
  Attributes:
11581 
   - scx
11582 
  """
11583 
 
11584 
  thrift_spec = (
11585 
    None, # 0
11586 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11587 
  )
11588 
 
11589 
  def __init__(self, scx=None,):
11590 
    self.scx = scx
11591 
 
11592 
  def read(self, iprot):
11593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11595 
      return
11596 
    iprot.readStructBegin()
11597 
    while True:
11598 
      (fname, ftype, fid) = iprot.readFieldBegin()
11599 
      if ftype == TType.STOP:
11600 
        break
11601 
      if fid == 1:
11602 
        if ftype == TType.STRUCT:
11603 
          self.scx = ShoppingCartException()
11604 
          self.scx.read(iprot)
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
11616 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11617 
    if self.scx is not None:
11618 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11619 
      self.scx.write(oprot)
11620 
      oprot.writeFieldEnd()
11621 
    oprot.writeFieldStop()
11622 
    oprot.writeStructEnd()
11623 
 
11624 
  def validate(self):
11625 
    return
11626 
 
11627 
 
11628 
  def __repr__(self):
11629 
    L = ['%s=%r' % (key, value)
11630 
      for key, value in self.__dict__.iteritems()]
11631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11632 
 
11633 
  def __eq__(self, other):
11634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11635 
 
11636 
  def __ne__(self, other):
11637 
    return not (self == other)
11638 
 
11639 
class saveDiscounts_args:
11640 
  """
11641 
  Attributes:
11642 
   - discounts
11643 
  """
11644 
 
11645 
  thrift_spec = (
11646 
    None, # 0
11647 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11648 
  )
11649 
 
11650 
  def __init__(self, discounts=None,):
11651 
    self.discounts = discounts
11652 
 
11653 
  def read(self, iprot):
11654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11656 
      return
11657 
    iprot.readStructBegin()
11658 
    while True:
11659 
      (fname, ftype, fid) = iprot.readFieldBegin()
11660 
      if ftype == TType.STOP:
11661 
        break
11662 
      if fid == 1:
11663 
        if ftype == TType.LIST:
11664 
          self.discounts = []
11592 amit.gupta 11665 
          (_etype163, _size160) = iprot.readListBegin()
11666 
          for _i164 in xrange(_size160):
11667 
            _elem165 = Discount()
11668 
            _elem165.read(iprot)
11669 
            self.discounts.append(_elem165)
3554 varun.gupt 11670 
          iprot.readListEnd()
11671 
        else:
11672 
          iprot.skip(ftype)
11673 
      else:
11674 
        iprot.skip(ftype)
11675 
      iprot.readFieldEnd()
11676 
    iprot.readStructEnd()
11677 
 
11678 
  def write(self, oprot):
11679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11681 
      return
11682 
    oprot.writeStructBegin('saveDiscounts_args')
11683 
    if self.discounts is not None:
11684 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11685 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11686 
      for iter166 in self.discounts:
11687 
        iter166.write(oprot)
3554 varun.gupt 11688 
      oprot.writeListEnd()
11689 
      oprot.writeFieldEnd()
11690 
    oprot.writeFieldStop()
11691 
    oprot.writeStructEnd()
11692 
 
11693 
  def validate(self):
11694 
    return
11695 
 
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 
 
11708 
class saveDiscounts_result:
11709 
  """
11710 
  Attributes:
11711 
   - scx
11712 
  """
11713 
 
11714 
  thrift_spec = (
11715 
    None, # 0
11716 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11717 
  )
11718 
 
11719 
  def __init__(self, scx=None,):
11720 
    self.scx = scx
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:
11732 
        if ftype == TType.STRUCT:
11733 
          self.scx = ShoppingCartException()
11734 
          self.scx.read(iprot)
11735 
        else:
11736 
          iprot.skip(ftype)
11737 
      else:
11738 
        iprot.skip(ftype)
11739 
      iprot.readFieldEnd()
11740 
    iprot.readStructEnd()
11741 
 
11742 
  def write(self, oprot):
11743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11745 
      return
11746 
    oprot.writeStructBegin('saveDiscounts_result')
11747 
    if self.scx is not None:
11748 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11749 
      self.scx.write(oprot)
11750 
      oprot.writeFieldEnd()
11751 
    oprot.writeFieldStop()
11752 
    oprot.writeStructEnd()
11753 
 
11754 
  def validate(self):
11755 
    return
11756 
 
11757 
 
11758 
  def __repr__(self):
11759 
    L = ['%s=%r' % (key, value)
11760 
      for key, value in self.__dict__.iteritems()]
11761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11762 
 
11763 
  def __eq__(self, other):
11764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11765 
 
11766 
  def __ne__(self, other):
11767 
    return not (self == other)
11768 
 
690 chandransh 11769 
class createOrders_args:
559 chandransh 11770 
  """
11771 
  Attributes:
11772 
   - cartId
2815 vikas 11773 
   - sessionSource
11774 
   - sessionStartTime
3858 vikas 11775 
   - firstSource
11776 
   - firstSourceTime
5326 rajveer 11777 
   - userId
6389 rajveer 11778 
   - schemeId
11526 amit.gupta 11779 
   - orderSource
559 chandransh 11780 
  """
11781 
 
11782 
  thrift_spec = (
11783 
    None, # 0
11784 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11785 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11786 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11787 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11788 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11789 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11790 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11791 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11792 
  )
11793 
 
11526 amit.gupta 11794 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11795 
    self.cartId = cartId
2815 vikas 11796 
    self.sessionSource = sessionSource
11797 
    self.sessionStartTime = sessionStartTime
3858 vikas 11798 
    self.firstSource = firstSource
11799 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11800 
    self.userId = userId
6389 rajveer 11801 
    self.schemeId = schemeId
11526 amit.gupta 11802 
    self.orderSource = orderSource
559 chandransh 11803 
 
11804 
  def read(self, iprot):
11805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11807 
      return
11808 
    iprot.readStructBegin()
11809 
    while True:
11810 
      (fname, ftype, fid) = iprot.readFieldBegin()
11811 
      if ftype == TType.STOP:
11812 
        break
11813 
      if fid == 1:
11814 
        if ftype == TType.I64:
11815 
          self.cartId = iprot.readI64();
11816 
        else:
11817 
          iprot.skip(ftype)
2815 vikas 11818 
      elif fid == 2:
11819 
        if ftype == TType.STRING:
11820 
          self.sessionSource = iprot.readString();
11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      elif fid == 3:
11824 
        if ftype == TType.I64:
11825 
          self.sessionStartTime = iprot.readI64();
11826 
        else:
11827 
          iprot.skip(ftype)
3858 vikas 11828 
      elif fid == 4:
11829 
        if ftype == TType.STRING:
11830 
          self.firstSource = iprot.readString();
11831 
        else:
11832 
          iprot.skip(ftype)
11833 
      elif fid == 5:
11834 
        if ftype == TType.I64:
11835 
          self.firstSourceTime = iprot.readI64();
11836 
        else:
11837 
          iprot.skip(ftype)
5326 rajveer 11838 
      elif fid == 6:
11839 
        if ftype == TType.I64:
11840 
          self.userId = iprot.readI64();
11841 
        else:
11842 
          iprot.skip(ftype)
6389 rajveer 11843 
      elif fid == 7:
11844 
        if ftype == TType.I64:
11845 
          self.schemeId = iprot.readI64();
11846 
        else:
11847 
          iprot.skip(ftype)
11526 amit.gupta 11848 
      elif fid == 8:
11849 
        if ftype == TType.I64:
11850 
          self.orderSource = iprot.readI64();
11851 
        else:
11852 
          iprot.skip(ftype)
559 chandransh 11853 
      else:
11854 
        iprot.skip(ftype)
11855 
      iprot.readFieldEnd()
11856 
    iprot.readStructEnd()
11857 
 
11858 
  def write(self, oprot):
11859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11861 
      return
690 chandransh 11862 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11863 
    if self.cartId is not None:
559 chandransh 11864 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11865 
      oprot.writeI64(self.cartId)
11866 
      oprot.writeFieldEnd()
3431 rajveer 11867 
    if self.sessionSource is not None:
2815 vikas 11868 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11869 
      oprot.writeString(self.sessionSource)
11870 
      oprot.writeFieldEnd()
3431 rajveer 11871 
    if self.sessionStartTime is not None:
2815 vikas 11872 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11873 
      oprot.writeI64(self.sessionStartTime)
11874 
      oprot.writeFieldEnd()
3858 vikas 11875 
    if self.firstSource is not None:
11876 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11877 
      oprot.writeString(self.firstSource)
11878 
      oprot.writeFieldEnd()
11879 
    if self.firstSourceTime is not None:
11880 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11881 
      oprot.writeI64(self.firstSourceTime)
11882 
      oprot.writeFieldEnd()
5326 rajveer 11883 
    if self.userId is not None:
11884 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11885 
      oprot.writeI64(self.userId)
11886 
      oprot.writeFieldEnd()
6389 rajveer 11887 
    if self.schemeId is not None:
11888 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11889 
      oprot.writeI64(self.schemeId)
11890 
      oprot.writeFieldEnd()
11526 amit.gupta 11891 
    if self.orderSource is not None:
11892 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
11893 
      oprot.writeI64(self.orderSource)
11894 
      oprot.writeFieldEnd()
559 chandransh 11895 
    oprot.writeFieldStop()
11896 
    oprot.writeStructEnd()
11897 
 
3431 rajveer 11898 
  def validate(self):
11899 
    return
11900 
 
11901 
 
559 chandransh 11902 
  def __repr__(self):
11903 
    L = ['%s=%r' % (key, value)
11904 
      for key, value in self.__dict__.iteritems()]
11905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11906 
 
11907 
  def __eq__(self, other):
11908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11909 
 
11910 
  def __ne__(self, other):
11911 
    return not (self == other)
11912 
 
690 chandransh 11913 
class createOrders_result:
559 chandransh 11914 
  """
11915 
  Attributes:
94 ashish 11916 
   - success
559 chandransh 11917 
   - scx
94 ashish 11918 
  """
11919 
 
11920 
  thrift_spec = (
575 chandransh 11921 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11922 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11923 
  )
11924 
 
559 chandransh 11925 
  def __init__(self, success=None, scx=None,):
94 ashish 11926 
    self.success = success
559 chandransh 11927 
    self.scx = scx
94 ashish 11928 
 
11929 
  def read(self, iprot):
11930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11932 
      return
11933 
    iprot.readStructBegin()
11934 
    while True:
11935 
      (fname, ftype, fid) = iprot.readFieldBegin()
11936 
      if ftype == TType.STOP:
11937 
        break
11938 
      if fid == 0:
575 chandransh 11939 
        if ftype == TType.I64:
11940 
          self.success = iprot.readI64();
94 ashish 11941 
        else:
11942 
          iprot.skip(ftype)
11943 
      elif fid == 1:
11944 
        if ftype == TType.STRUCT:
559 chandransh 11945 
          self.scx = ShoppingCartException()
11946 
          self.scx.read(iprot)
94 ashish 11947 
        else:
11948 
          iprot.skip(ftype)
11949 
      else:
11950 
        iprot.skip(ftype)
11951 
      iprot.readFieldEnd()
11952 
    iprot.readStructEnd()
11953 
 
11954 
  def write(self, oprot):
11955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11957 
      return
690 chandransh 11958 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 11959 
    if self.success is not None:
575 chandransh 11960 
      oprot.writeFieldBegin('success', TType.I64, 0)
11961 
      oprot.writeI64(self.success)
94 ashish 11962 
      oprot.writeFieldEnd()
3431 rajveer 11963 
    if self.scx is not None:
559 chandransh 11964 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11965 
      self.scx.write(oprot)
94 ashish 11966 
      oprot.writeFieldEnd()
11967 
    oprot.writeFieldStop()
11968 
    oprot.writeStructEnd()
11969 
 
3431 rajveer 11970 
  def validate(self):
11971 
    return
11972 
 
11973 
 
94 ashish 11974 
  def __repr__(self):
11975 
    L = ['%s=%r' % (key, value)
11976 
      for key, value in self.__dict__.iteritems()]
11977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11978 
 
11979 
  def __eq__(self, other):
11980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11981 
 
11982 
  def __ne__(self, other):
11983 
    return not (self == other)
11984 
 
559 chandransh 11985 
class validateCart_args:
94 ashish 11986 
  """
11987 
  Attributes:
559 chandransh 11988 
   - cartId
3557 rajveer 11989 
   - sourceId
94 ashish 11990 
  """
11991 
 
11992 
  thrift_spec = (
11993 
    None, # 0
559 chandransh 11994 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 11995 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 11996 
  )
11997 
 
3557 rajveer 11998 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 11999 
    self.cartId = cartId
3557 rajveer 12000 
    self.sourceId = sourceId
94 ashish 12001 
 
12002 
  def read(self, iprot):
12003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12005 
      return
12006 
    iprot.readStructBegin()
12007 
    while True:
12008 
      (fname, ftype, fid) = iprot.readFieldBegin()
12009 
      if ftype == TType.STOP:
12010 
        break
12011 
      if fid == 1:
12012 
        if ftype == TType.I64:
559 chandransh 12013 
          self.cartId = iprot.readI64();
94 ashish 12014 
        else:
12015 
          iprot.skip(ftype)
3557 rajveer 12016 
      elif fid == 2:
12017 
        if ftype == TType.I64:
12018 
          self.sourceId = iprot.readI64();
12019 
        else:
12020 
          iprot.skip(ftype)
94 ashish 12021 
      else:
12022 
        iprot.skip(ftype)
12023 
      iprot.readFieldEnd()
12024 
    iprot.readStructEnd()
12025 
 
12026 
  def write(self, oprot):
12027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12029 
      return
559 chandransh 12030 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12031 
    if self.cartId is not None:
559 chandransh 12032 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12033 
      oprot.writeI64(self.cartId)
94 ashish 12034 
      oprot.writeFieldEnd()
3557 rajveer 12035 
    if self.sourceId is not None:
12036 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12037 
      oprot.writeI64(self.sourceId)
12038 
      oprot.writeFieldEnd()
94 ashish 12039 
    oprot.writeFieldStop()
12040 
    oprot.writeStructEnd()
12041 
 
3431 rajveer 12042 
  def validate(self):
12043 
    return
12044 
 
12045 
 
94 ashish 12046 
  def __repr__(self):
12047 
    L = ['%s=%r' % (key, value)
12048 
      for key, value in self.__dict__.iteritems()]
12049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12050 
 
12051 
  def __eq__(self, other):
12052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12053 
 
12054 
  def __ne__(self, other):
12055 
    return not (self == other)
12056 
 
559 chandransh 12057 
class validateCart_result:
94 ashish 12058 
  """
12059 
  Attributes:
12060 
   - success
575 chandransh 12061 
   - scex
94 ashish 12062 
  """
12063 
 
12064 
  thrift_spec = (
6736 amit.gupta 12065 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12066 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12067 
  )
12068 
 
575 chandransh 12069 
  def __init__(self, success=None, scex=None,):
94 ashish 12070 
    self.success = success
575 chandransh 12071 
    self.scex = scex
94 ashish 12072 
 
12073 
  def read(self, iprot):
12074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12076 
      return
12077 
    iprot.readStructBegin()
12078 
    while True:
12079 
      (fname, ftype, fid) = iprot.readFieldBegin()
12080 
      if ftype == TType.STOP:
12081 
        break
12082 
      if fid == 0:
6736 amit.gupta 12083 
        if ftype == TType.LIST:
12084 
          self.success = []
11592 amit.gupta 12085 
          (_etype170, _size167) = iprot.readListBegin()
12086 
          for _i171 in xrange(_size167):
12087 
            _elem172 = iprot.readString();
12088 
            self.success.append(_elem172)
6736 amit.gupta 12089 
          iprot.readListEnd()
94 ashish 12090 
        else:
12091 
          iprot.skip(ftype)
575 chandransh 12092 
      elif fid == 1:
12093 
        if ftype == TType.STRUCT:
12094 
          self.scex = ShoppingCartException()
12095 
          self.scex.read(iprot)
12096 
        else:
12097 
          iprot.skip(ftype)
94 ashish 12098 
      else:
12099 
        iprot.skip(ftype)
12100 
      iprot.readFieldEnd()
12101 
    iprot.readStructEnd()
12102 
 
12103 
  def write(self, oprot):
12104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12106 
      return
559 chandransh 12107 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12108 
    if self.success is not None:
6736 amit.gupta 12109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12110 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12111 
      for iter173 in self.success:
12112 
        oprot.writeString(iter173)
6736 amit.gupta 12113 
      oprot.writeListEnd()
94 ashish 12114 
      oprot.writeFieldEnd()
3431 rajveer 12115 
    if self.scex is not None:
575 chandransh 12116 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12117 
      self.scex.write(oprot)
12118 
      oprot.writeFieldEnd()
559 chandransh 12119 
    oprot.writeFieldStop()
12120 
    oprot.writeStructEnd()
12121 
 
3431 rajveer 12122 
  def validate(self):
12123 
    return
12124 
 
12125 
 
559 chandransh 12126 
  def __repr__(self):
12127 
    L = ['%s=%r' % (key, value)
12128 
      for key, value in self.__dict__.iteritems()]
12129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12130 
 
12131 
  def __eq__(self, other):
12132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12133 
 
12134 
  def __ne__(self, other):
12135 
    return not (self == other)
12136 
 
11980 amit.gupta 12137 
class validateCartWithDealerCoupon_args:
12138 
  """
12139 
  Attributes:
12140 
   - cartId
12141 
   - sourceId
12142 
   - dealCoupon
12143 
  """
12144 
 
12145 
  thrift_spec = (
12146 
    None, # 0
12147 
    (1, TType.I64, 'cartId', None, None, ), # 1
12148 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12149 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12150 
  )
12151 
 
12152 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12153 
    self.cartId = cartId
12154 
    self.sourceId = sourceId
12155 
    self.dealCoupon = dealCoupon
12156 
 
12157 
  def read(self, iprot):
12158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12160 
      return
12161 
    iprot.readStructBegin()
12162 
    while True:
12163 
      (fname, ftype, fid) = iprot.readFieldBegin()
12164 
      if ftype == TType.STOP:
12165 
        break
12166 
      if fid == 1:
12167 
        if ftype == TType.I64:
12168 
          self.cartId = iprot.readI64();
12169 
        else:
12170 
          iprot.skip(ftype)
12171 
      elif fid == 2:
12172 
        if ftype == TType.I64:
12173 
          self.sourceId = iprot.readI64();
12174 
        else:
12175 
          iprot.skip(ftype)
12176 
      elif fid == 3:
12177 
        if ftype == TType.STRING:
12178 
          self.dealCoupon = iprot.readString();
12179 
        else:
12180 
          iprot.skip(ftype)
12181 
      else:
12182 
        iprot.skip(ftype)
12183 
      iprot.readFieldEnd()
12184 
    iprot.readStructEnd()
12185 
 
12186 
  def write(self, oprot):
12187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12189 
      return
12190 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12191 
    if self.cartId is not None:
12192 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12193 
      oprot.writeI64(self.cartId)
12194 
      oprot.writeFieldEnd()
12195 
    if self.sourceId is not None:
12196 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12197 
      oprot.writeI64(self.sourceId)
12198 
      oprot.writeFieldEnd()
12199 
    if self.dealCoupon is not None:
12200 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12201 
      oprot.writeString(self.dealCoupon)
12202 
      oprot.writeFieldEnd()
12203 
    oprot.writeFieldStop()
12204 
    oprot.writeStructEnd()
12205 
 
12206 
  def validate(self):
12207 
    return
12208 
 
12209 
 
12210 
  def __repr__(self):
12211 
    L = ['%s=%r' % (key, value)
12212 
      for key, value in self.__dict__.iteritems()]
12213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12214 
 
12215 
  def __eq__(self, other):
12216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12217 
 
12218 
  def __ne__(self, other):
12219 
    return not (self == other)
12220 
 
12221 
class validateCartWithDealerCoupon_result:
12222 
  """
12223 
  Attributes:
12224 
   - success
12225 
   - scex
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12230 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12231 
  )
12232 
 
12233 
  def __init__(self, success=None, scex=None,):
12234 
    self.success = success
12235 
    self.scex = scex
12236 
 
12237 
  def read(self, iprot):
12238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12240 
      return
12241 
    iprot.readStructBegin()
12242 
    while True:
12243 
      (fname, ftype, fid) = iprot.readFieldBegin()
12244 
      if ftype == TType.STOP:
12245 
        break
12246 
      if fid == 0:
12247 
        if ftype == TType.LIST:
12248 
          self.success = []
12249 
          (_etype177, _size174) = iprot.readListBegin()
12250 
          for _i178 in xrange(_size174):
12251 
            _elem179 = iprot.readString();
12252 
            self.success.append(_elem179)
12253 
          iprot.readListEnd()
12254 
        else:
12255 
          iprot.skip(ftype)
12256 
      elif fid == 1:
12257 
        if ftype == TType.STRUCT:
12258 
          self.scex = ShoppingCartException()
12259 
          self.scex.read(iprot)
12260 
        else:
12261 
          iprot.skip(ftype)
12262 
      else:
12263 
        iprot.skip(ftype)
12264 
      iprot.readFieldEnd()
12265 
    iprot.readStructEnd()
12266 
 
12267 
  def write(self, oprot):
12268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12270 
      return
12271 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12272 
    if self.success is not None:
12273 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12274 
      oprot.writeListBegin(TType.STRING, len(self.success))
12275 
      for iter180 in self.success:
12276 
        oprot.writeString(iter180)
12277 
      oprot.writeListEnd()
12278 
      oprot.writeFieldEnd()
12279 
    if self.scex is not None:
12280 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12281 
      self.scex.write(oprot)
12282 
      oprot.writeFieldEnd()
12283 
    oprot.writeFieldStop()
12284 
    oprot.writeStructEnd()
12285 
 
12286 
  def validate(self):
12287 
    return
12288 
 
12289 
 
12290 
  def __repr__(self):
12291 
    L = ['%s=%r' % (key, value)
12292 
      for key, value in self.__dict__.iteritems()]
12293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12294 
 
12295 
  def __eq__(self, other):
12296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12297 
 
12298 
  def __ne__(self, other):
12299 
    return not (self == other)
12300 
 
690 chandransh 12301 
class mergeCart_args:
575 chandransh 12302 
  """
12303 
  Attributes:
690 chandransh 12304 
   - fromCartId
12305 
   - toCartId
12306 
  """
12307 
 
12308 
  thrift_spec = (
12309 
    None, # 0
12310 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12311 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12312 
  )
12313 
 
12314 
  def __init__(self, fromCartId=None, toCartId=None,):
12315 
    self.fromCartId = fromCartId
12316 
    self.toCartId = toCartId
12317 
 
12318 
  def read(self, iprot):
12319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12321 
      return
12322 
    iprot.readStructBegin()
12323 
    while True:
12324 
      (fname, ftype, fid) = iprot.readFieldBegin()
12325 
      if ftype == TType.STOP:
12326 
        break
12327 
      if fid == 1:
12328 
        if ftype == TType.I64:
12329 
          self.fromCartId = iprot.readI64();
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      elif fid == 2:
12333 
        if ftype == TType.I64:
12334 
          self.toCartId = iprot.readI64();
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      else:
12338 
        iprot.skip(ftype)
12339 
      iprot.readFieldEnd()
12340 
    iprot.readStructEnd()
12341 
 
12342 
  def write(self, oprot):
12343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12345 
      return
12346 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12347 
    if self.fromCartId is not None:
690 chandransh 12348 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12349 
      oprot.writeI64(self.fromCartId)
12350 
      oprot.writeFieldEnd()
3431 rajveer 12351 
    if self.toCartId is not None:
690 chandransh 12352 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12353 
      oprot.writeI64(self.toCartId)
12354 
      oprot.writeFieldEnd()
12355 
    oprot.writeFieldStop()
12356 
    oprot.writeStructEnd()
12357 
 
3431 rajveer 12358 
  def validate(self):
12359 
    return
12360 
 
12361 
 
690 chandransh 12362 
  def __repr__(self):
12363 
    L = ['%s=%r' % (key, value)
12364 
      for key, value in self.__dict__.iteritems()]
12365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12366 
 
12367 
  def __eq__(self, other):
12368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12369 
 
12370 
  def __ne__(self, other):
12371 
    return not (self == other)
12372 
 
12373 
class mergeCart_result:
12374 
 
12375 
  thrift_spec = (
12376 
  )
12377 
 
12378 
  def read(self, iprot):
12379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12381 
      return
12382 
    iprot.readStructBegin()
12383 
    while True:
12384 
      (fname, ftype, fid) = iprot.readFieldBegin()
12385 
      if ftype == TType.STOP:
12386 
        break
12387 
      else:
12388 
        iprot.skip(ftype)
12389 
      iprot.readFieldEnd()
12390 
    iprot.readStructEnd()
12391 
 
12392 
  def write(self, oprot):
12393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12395 
      return
12396 
    oprot.writeStructBegin('mergeCart_result')
12397 
    oprot.writeFieldStop()
12398 
    oprot.writeStructEnd()
12399 
 
3431 rajveer 12400 
  def validate(self):
12401 
    return
12402 
 
12403 
 
690 chandransh 12404 
  def __repr__(self):
12405 
    L = ['%s=%r' % (key, value)
12406 
      for key, value in self.__dict__.iteritems()]
12407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12408 
 
12409 
  def __eq__(self, other):
12410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12411 
 
12412 
  def __ne__(self, other):
12413 
    return not (self == other)
12414 
 
12415 
class checkOut_args:
12416 
  """
12417 
  Attributes:
575 chandransh 12418 
   - cartId
12419 
  """
12420 
 
12421 
  thrift_spec = (
12422 
    None, # 0
12423 
    (1, TType.I64, 'cartId', None, None, ), # 1
12424 
  )
12425 
 
12426 
  def __init__(self, cartId=None,):
12427 
    self.cartId = cartId
12428 
 
12429 
  def read(self, iprot):
12430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12432 
      return
12433 
    iprot.readStructBegin()
12434 
    while True:
12435 
      (fname, ftype, fid) = iprot.readFieldBegin()
12436 
      if ftype == TType.STOP:
12437 
        break
12438 
      if fid == 1:
12439 
        if ftype == TType.I64:
12440 
          self.cartId = iprot.readI64();
12441 
        else:
12442 
          iprot.skip(ftype)
12443 
      else:
12444 
        iprot.skip(ftype)
12445 
      iprot.readFieldEnd()
12446 
    iprot.readStructEnd()
12447 
 
12448 
  def write(self, oprot):
12449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12451 
      return
690 chandransh 12452 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12453 
    if self.cartId is not None:
575 chandransh 12454 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12455 
      oprot.writeI64(self.cartId)
12456 
      oprot.writeFieldEnd()
12457 
    oprot.writeFieldStop()
12458 
    oprot.writeStructEnd()
12459 
 
3431 rajveer 12460 
  def validate(self):
12461 
    return
12462 
 
12463 
 
575 chandransh 12464 
  def __repr__(self):
12465 
    L = ['%s=%r' % (key, value)
12466 
      for key, value in self.__dict__.iteritems()]
12467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12468 
 
12469 
  def __eq__(self, other):
12470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12471 
 
12472 
  def __ne__(self, other):
12473 
    return not (self == other)
12474 
 
690 chandransh 12475 
class checkOut_result:
575 chandransh 12476 
  """
12477 
  Attributes:
12478 
   - success
12479 
   - scex
12480 
  """
12481 
 
12482 
  thrift_spec = (
12483 
    (0, TType.BOOL, 'success', None, None, ), # 0
12484 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12485 
  )
12486 
 
12487 
  def __init__(self, success=None, scex=None,):
12488 
    self.success = success
12489 
    self.scex = scex
12490 
 
12491 
  def read(self, iprot):
12492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12494 
      return
12495 
    iprot.readStructBegin()
12496 
    while True:
12497 
      (fname, ftype, fid) = iprot.readFieldBegin()
12498 
      if ftype == TType.STOP:
12499 
        break
12500 
      if fid == 0:
12501 
        if ftype == TType.BOOL:
12502 
          self.success = iprot.readBool();
12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      elif fid == 1:
12506 
        if ftype == TType.STRUCT:
12507 
          self.scex = ShoppingCartException()
12508 
          self.scex.read(iprot)
12509 
        else:
12510 
          iprot.skip(ftype)
12511 
      else:
12512 
        iprot.skip(ftype)
12513 
      iprot.readFieldEnd()
12514 
    iprot.readStructEnd()
12515 
 
12516 
  def write(self, oprot):
12517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12519 
      return
690 chandransh 12520 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12521 
    if self.success is not None:
575 chandransh 12522 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12523 
      oprot.writeBool(self.success)
12524 
      oprot.writeFieldEnd()
3431 rajveer 12525 
    if self.scex is not None:
575 chandransh 12526 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12527 
      self.scex.write(oprot)
12528 
      oprot.writeFieldEnd()
12529 
    oprot.writeFieldStop()
12530 
    oprot.writeStructEnd()
12531 
 
3431 rajveer 12532 
  def validate(self):
12533 
    return
12534 
 
12535 
 
575 chandransh 12536 
  def __repr__(self):
12537 
    L = ['%s=%r' % (key, value)
12538 
      for key, value in self.__dict__.iteritems()]
12539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12540 
 
12541 
  def __eq__(self, other):
12542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12543 
 
12544 
  def __ne__(self, other):
12545 
    return not (self == other)
12546 
 
690 chandransh 12547 
class resetCart_args:
559 chandransh 12548 
  """
12549 
  Attributes:
690 chandransh 12550 
   - cartId
12551 
   - items
559 chandransh 12552 
  """
12553 
 
12554 
  thrift_spec = (
12555 
    None, # 0
690 chandransh 12556 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12557 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12558 
  )
12559 
 
690 chandransh 12560 
  def __init__(self, cartId=None, items=None,):
12561 
    self.cartId = cartId
12562 
    self.items = items
559 chandransh 12563 
 
12564 
  def read(self, iprot):
12565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12567 
      return
12568 
    iprot.readStructBegin()
12569 
    while True:
12570 
      (fname, ftype, fid) = iprot.readFieldBegin()
12571 
      if ftype == TType.STOP:
12572 
        break
12573 
      if fid == 1:
12574 
        if ftype == TType.I64:
690 chandransh 12575 
          self.cartId = iprot.readI64();
559 chandransh 12576 
        else:
12577 
          iprot.skip(ftype)
12578 
      elif fid == 2:
690 chandransh 12579 
        if ftype == TType.MAP:
12580 
          self.items = {}
11980 amit.gupta 12581 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12582 
          for _i185 in xrange(_size181):
12583 
            _key186 = iprot.readI64();
12584 
            _val187 = iprot.readDouble();
12585 
            self.items[_key186] = _val187
690 chandransh 12586 
          iprot.readMapEnd()
559 chandransh 12587 
        else:
12588 
          iprot.skip(ftype)
12589 
      else:
12590 
        iprot.skip(ftype)
12591 
      iprot.readFieldEnd()
12592 
    iprot.readStructEnd()
12593 
 
12594 
  def write(self, oprot):
12595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12597 
      return
690 chandransh 12598 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12599 
    if self.cartId is not None:
690 chandransh 12600 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12601 
      oprot.writeI64(self.cartId)
94 ashish 12602 
      oprot.writeFieldEnd()
3431 rajveer 12603 
    if self.items is not None:
690 chandransh 12604 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12605 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12606 
      for kiter188,viter189 in self.items.items():
12607 
        oprot.writeI64(kiter188)
12608 
        oprot.writeDouble(viter189)
690 chandransh 12609 
      oprot.writeMapEnd()
559 chandransh 12610 
      oprot.writeFieldEnd()
94 ashish 12611 
    oprot.writeFieldStop()
12612 
    oprot.writeStructEnd()
12613 
 
3431 rajveer 12614 
  def validate(self):
12615 
    return
12616 
 
12617 
 
94 ashish 12618 
  def __repr__(self):
12619 
    L = ['%s=%r' % (key, value)
12620 
      for key, value in self.__dict__.iteritems()]
12621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12622 
 
12623 
  def __eq__(self, other):
12624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12625 
 
12626 
  def __ne__(self, other):
12627 
    return not (self == other)
12628 
 
690 chandransh 12629 
class resetCart_result:
12630 
  """
12631 
  Attributes:
12632 
   - success
12633 
   - scex
12634 
  """
559 chandransh 12635 
 
12636 
  thrift_spec = (
690 chandransh 12637 
    (0, TType.BOOL, 'success', None, None, ), # 0
12638 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12639 
  )
12640 
 
690 chandransh 12641 
  def __init__(self, success=None, scex=None,):
12642 
    self.success = success
12643 
    self.scex = scex
12644 
 
559 chandransh 12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
690 chandransh 12654 
      if fid == 0:
12655 
        if ftype == TType.BOOL:
12656 
          self.success = iprot.readBool();
12657 
        else:
12658 
          iprot.skip(ftype)
12659 
      elif fid == 1:
12660 
        if ftype == TType.STRUCT:
12661 
          self.scex = ShoppingCartException()
12662 
          self.scex.read(iprot)
12663 
        else:
12664 
          iprot.skip(ftype)
559 chandransh 12665 
      else:
12666 
        iprot.skip(ftype)
12667 
      iprot.readFieldEnd()
12668 
    iprot.readStructEnd()
12669 
 
12670 
  def write(self, oprot):
12671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12673 
      return
690 chandransh 12674 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12675 
    if self.success is not None:
690 chandransh 12676 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12677 
      oprot.writeBool(self.success)
12678 
      oprot.writeFieldEnd()
3431 rajveer 12679 
    if self.scex is not None:
690 chandransh 12680 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12681 
      self.scex.write(oprot)
12682 
      oprot.writeFieldEnd()
559 chandransh 12683 
    oprot.writeFieldStop()
12684 
    oprot.writeStructEnd()
12685 
 
3431 rajveer 12686 
  def validate(self):
12687 
    return
12688 
 
12689 
 
559 chandransh 12690 
  def __repr__(self):
12691 
    L = ['%s=%r' % (key, value)
12692 
      for key, value in self.__dict__.iteritems()]
12693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12694 
 
12695 
  def __eq__(self, other):
12696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12697 
 
12698 
  def __ne__(self, other):
12699 
    return not (self == other)
12700 
 
2981 rajveer 12701 
class getUserCount_args:
94 ashish 12702 
  """
12703 
  Attributes:
2981 rajveer 12704 
   - userType
559 chandransh 12705 
  """
12706 
 
12707 
  thrift_spec = (
12708 
    None, # 0
2981 rajveer 12709 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12710 
  )
12711 
 
2981 rajveer 12712 
  def __init__(self, userType=None,):
12713 
    self.userType = userType
559 chandransh 12714 
 
12715 
  def read(self, iprot):
12716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12718 
      return
12719 
    iprot.readStructBegin()
12720 
    while True:
12721 
      (fname, ftype, fid) = iprot.readFieldBegin()
12722 
      if ftype == TType.STOP:
12723 
        break
12724 
      if fid == 1:
2981 rajveer 12725 
        if ftype == TType.I32:
12726 
          self.userType = iprot.readI32();
559 chandransh 12727 
        else:
12728 
          iprot.skip(ftype)
12729 
      else:
12730 
        iprot.skip(ftype)
12731 
      iprot.readFieldEnd()
12732 
    iprot.readStructEnd()
12733 
 
12734 
  def write(self, oprot):
12735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12737 
      return
2981 rajveer 12738 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12739 
    if self.userType is not None:
2981 rajveer 12740 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12741 
      oprot.writeI32(self.userType)
559 chandransh 12742 
      oprot.writeFieldEnd()
12743 
    oprot.writeFieldStop()
12744 
    oprot.writeStructEnd()
12745 
 
3431 rajveer 12746 
  def validate(self):
12747 
    return
12748 
 
12749 
 
559 chandransh 12750 
  def __repr__(self):
12751 
    L = ['%s=%r' % (key, value)
12752 
      for key, value in self.__dict__.iteritems()]
12753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12754 
 
12755 
  def __eq__(self, other):
12756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12757 
 
12758 
  def __ne__(self, other):
12759 
    return not (self == other)
12760 
 
2981 rajveer 12761 
class getUserCount_result:
94 ashish 12762 
  """
12763 
  Attributes:
12764 
   - success
12765 
  """
12766 
 
12767 
  thrift_spec = (
2981 rajveer 12768 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12769 
  )
12770 
 
2981 rajveer 12771 
  def __init__(self, success=None,):
94 ashish 12772 
    self.success = success
12773 
 
12774 
  def read(self, iprot):
12775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12777 
      return
12778 
    iprot.readStructBegin()
12779 
    while True:
12780 
      (fname, ftype, fid) = iprot.readFieldBegin()
12781 
      if ftype == TType.STOP:
12782 
        break
12783 
      if fid == 0:
2981 rajveer 12784 
        if ftype == TType.I64:
12785 
          self.success = iprot.readI64();
94 ashish 12786 
        else:
12787 
          iprot.skip(ftype)
12788 
      else:
12789 
        iprot.skip(ftype)
12790 
      iprot.readFieldEnd()
12791 
    iprot.readStructEnd()
12792 
 
12793 
  def write(self, oprot):
12794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12796 
      return
2981 rajveer 12797 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12798 
    if self.success is not None:
2981 rajveer 12799 
      oprot.writeFieldBegin('success', TType.I64, 0)
12800 
      oprot.writeI64(self.success)
94 ashish 12801 
      oprot.writeFieldEnd()
12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
3431 rajveer 12805 
  def validate(self):
12806 
    return
12807 
 
12808 
 
94 ashish 12809 
  def __repr__(self):
12810 
    L = ['%s=%r' % (key, value)
12811 
      for key, value in self.__dict__.iteritems()]
12812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12813 
 
12814 
  def __eq__(self, other):
12815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12816 
 
12817 
  def __ne__(self, other):
12818 
    return not (self == other)
12819 
 
2981 rajveer 12820 
class getAllUsers_args:
94 ashish 12821 
  """
12822 
  Attributes:
2981 rajveer 12823 
   - userType
12824 
   - startDate
12825 
   - endDate
94 ashish 12826 
  """
12827 
 
12828 
  thrift_spec = (
12829 
    None, # 0
2981 rajveer 12830 
    (1, TType.I32, 'userType', None, None, ), # 1
12831 
    (2, TType.I64, 'startDate', None, None, ), # 2
12832 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12833 
  )
12834 
 
2981 rajveer 12835 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12836 
    self.userType = userType
12837 
    self.startDate = startDate
12838 
    self.endDate = endDate
94 ashish 12839 
 
12840 
  def read(self, iprot):
12841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12843 
      return
12844 
    iprot.readStructBegin()
12845 
    while True:
12846 
      (fname, ftype, fid) = iprot.readFieldBegin()
12847 
      if ftype == TType.STOP:
12848 
        break
12849 
      if fid == 1:
2981 rajveer 12850 
        if ftype == TType.I32:
12851 
          self.userType = iprot.readI32();
94 ashish 12852 
        else:
12853 
          iprot.skip(ftype)
12854 
      elif fid == 2:
559 chandransh 12855 
        if ftype == TType.I64:
2981 rajveer 12856 
          self.startDate = iprot.readI64();
94 ashish 12857 
        else:
12858 
          iprot.skip(ftype)
2981 rajveer 12859 
      elif fid == 3:
12860 
        if ftype == TType.I64:
12861 
          self.endDate = iprot.readI64();
12862 
        else:
12863 
          iprot.skip(ftype)
94 ashish 12864 
      else:
12865 
        iprot.skip(ftype)
12866 
      iprot.readFieldEnd()
12867 
    iprot.readStructEnd()
12868 
 
12869 
  def write(self, oprot):
12870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12872 
      return
2981 rajveer 12873 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12874 
    if self.userType is not None:
2981 rajveer 12875 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12876 
      oprot.writeI32(self.userType)
94 ashish 12877 
      oprot.writeFieldEnd()
3431 rajveer 12878 
    if self.startDate is not None:
2981 rajveer 12879 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12880 
      oprot.writeI64(self.startDate)
94 ashish 12881 
      oprot.writeFieldEnd()
3431 rajveer 12882 
    if self.endDate is not None:
2981 rajveer 12883 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12884 
      oprot.writeI64(self.endDate)
12885 
      oprot.writeFieldEnd()
94 ashish 12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
3431 rajveer 12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
94 ashish 12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
12903 
 
2981 rajveer 12904 
class getAllUsers_result:
94 ashish 12905 
  """
12906 
  Attributes:
12907 
   - success
12908 
  """
12909 
 
12910 
  thrift_spec = (
2981 rajveer 12911 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 12912 
  )
12913 
 
2981 rajveer 12914 
  def __init__(self, success=None,):
94 ashish 12915 
    self.success = success
12916 
 
12917 
  def read(self, iprot):
12918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12920 
      return
12921 
    iprot.readStructBegin()
12922 
    while True:
12923 
      (fname, ftype, fid) = iprot.readFieldBegin()
12924 
      if ftype == TType.STOP:
12925 
        break
12926 
      if fid == 0:
2981 rajveer 12927 
        if ftype == TType.LIST:
12928 
          self.success = []
11980 amit.gupta 12929 
          (_etype193, _size190) = iprot.readListBegin()
12930 
          for _i194 in xrange(_size190):
12931 
            _elem195 = User()
12932 
            _elem195.read(iprot)
12933 
            self.success.append(_elem195)
2981 rajveer 12934 
          iprot.readListEnd()
94 ashish 12935 
        else:
12936 
          iprot.skip(ftype)
12937 
      else:
12938 
        iprot.skip(ftype)
12939 
      iprot.readFieldEnd()
12940 
    iprot.readStructEnd()
12941 
 
12942 
  def write(self, oprot):
12943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12945 
      return
2981 rajveer 12946 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 12947 
    if self.success is not None:
2981 rajveer 12948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 12950 
      for iter196 in self.success:
12951 
        iter196.write(oprot)
2981 rajveer 12952 
      oprot.writeListEnd()
94 ashish 12953 
      oprot.writeFieldEnd()
12954 
    oprot.writeFieldStop()
12955 
    oprot.writeStructEnd()
12956 
 
3431 rajveer 12957 
  def validate(self):
12958 
    return
12959 
 
12960 
 
94 ashish 12961 
  def __repr__(self):
12962 
    L = ['%s=%r' % (key, value)
12963 
      for key, value in self.__dict__.iteritems()]
12964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12965 
 
12966 
  def __eq__(self, other):
12967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12968 
 
12969 
  def __ne__(self, other):
12970 
    return not (self == other)
12971 
 
2981 rajveer 12972 
class getMyResearchItems_args:
559 chandransh 12973 
  """
12974 
  Attributes:
772 rajveer 12975 
   - userId
559 chandransh 12976 
  """
12977 
 
12978 
  thrift_spec = (
12979 
    None, # 0
772 rajveer 12980 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12981 
  )
12982 
 
772 rajveer 12983 
  def __init__(self, userId=None,):
12984 
    self.userId = userId
559 chandransh 12985 
 
12986 
  def read(self, iprot):
12987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12989 
      return
12990 
    iprot.readStructBegin()
12991 
    while True:
12992 
      (fname, ftype, fid) = iprot.readFieldBegin()
12993 
      if ftype == TType.STOP:
12994 
        break
12995 
      if fid == 1:
12996 
        if ftype == TType.I64:
772 rajveer 12997 
          self.userId = iprot.readI64();
559 chandransh 12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
2981 rajveer 13009 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13010 
    if self.userId is not None:
772 rajveer 13011 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13012 
      oprot.writeI64(self.userId)
559 chandransh 13013 
      oprot.writeFieldEnd()
13014 
    oprot.writeFieldStop()
13015 
    oprot.writeStructEnd()
13016 
 
3431 rajveer 13017 
  def validate(self):
13018 
    return
13019 
 
13020 
 
559 chandransh 13021 
  def __repr__(self):
13022 
    L = ['%s=%r' % (key, value)
13023 
      for key, value in self.__dict__.iteritems()]
13024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13025 
 
13026 
  def __eq__(self, other):
13027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13028 
 
13029 
  def __ne__(self, other):
13030 
    return not (self == other)
13031 
 
2981 rajveer 13032 
class getMyResearchItems_result:
559 chandransh 13033 
  """
13034 
  Attributes:
130 ashish 13035 
   - success
559 chandransh 13036 
   - scx
130 ashish 13037 
  """
13038 
 
13039 
  thrift_spec = (
2981 rajveer 13040 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13041 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13042 
  )
13043 
 
559 chandransh 13044 
  def __init__(self, success=None, scx=None,):
130 ashish 13045 
    self.success = success
559 chandransh 13046 
    self.scx = scx
130 ashish 13047 
 
13048 
  def read(self, iprot):
13049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13051 
      return
13052 
    iprot.readStructBegin()
13053 
    while True:
13054 
      (fname, ftype, fid) = iprot.readFieldBegin()
13055 
      if ftype == TType.STOP:
13056 
        break
13057 
      if fid == 0:
2981 rajveer 13058 
        if ftype == TType.LIST:
13059 
          self.success = []
11980 amit.gupta 13060 
          (_etype200, _size197) = iprot.readListBegin()
13061 
          for _i201 in xrange(_size197):
13062 
            _elem202 = iprot.readI64();
13063 
            self.success.append(_elem202)
2981 rajveer 13064 
          iprot.readListEnd()
130 ashish 13065 
        else:
13066 
          iprot.skip(ftype)
13067 
      elif fid == 1:
13068 
        if ftype == TType.STRUCT:
559 chandransh 13069 
          self.scx = WidgetException()
13070 
          self.scx.read(iprot)
130 ashish 13071 
        else:
13072 
          iprot.skip(ftype)
13073 
      else:
13074 
        iprot.skip(ftype)
13075 
      iprot.readFieldEnd()
13076 
    iprot.readStructEnd()
13077 
 
13078 
  def write(self, oprot):
13079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13081 
      return
2981 rajveer 13082 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13083 
    if self.success is not None:
2981 rajveer 13084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13085 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13086 
      for iter203 in self.success:
13087 
        oprot.writeI64(iter203)
2981 rajveer 13088 
      oprot.writeListEnd()
130 ashish 13089 
      oprot.writeFieldEnd()
3431 rajveer 13090 
    if self.scx is not None:
559 chandransh 13091 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13092 
      self.scx.write(oprot)
130 ashish 13093 
      oprot.writeFieldEnd()
13094 
    oprot.writeFieldStop()
13095 
    oprot.writeStructEnd()
13096 
 
3431 rajveer 13097 
  def validate(self):
13098 
    return
13099 
 
13100 
 
130 ashish 13101 
  def __repr__(self):
13102 
    L = ['%s=%r' % (key, value)
13103 
      for key, value in self.__dict__.iteritems()]
13104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13105 
 
13106 
  def __eq__(self, other):
13107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13108 
 
13109 
  def __ne__(self, other):
13110 
    return not (self == other)
13111 
 
2981 rajveer 13112 
class updateMyResearch_args:
130 ashish 13113 
  """
13114 
  Attributes:
2981 rajveer 13115 
   - userId
13116 
   - itemId
130 ashish 13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
2981 rajveer 13121 
    (1, TType.I64, 'userId', None, None, ), # 1
13122 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13123 
  )
13124 
 
2981 rajveer 13125 
  def __init__(self, userId=None, itemId=None,):
13126 
    self.userId = userId
13127 
    self.itemId = itemId
130 ashish 13128 
 
13129 
  def read(self, iprot):
13130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13132 
      return
13133 
    iprot.readStructBegin()
13134 
    while True:
13135 
      (fname, ftype, fid) = iprot.readFieldBegin()
13136 
      if ftype == TType.STOP:
13137 
        break
13138 
      if fid == 1:
559 chandransh 13139 
        if ftype == TType.I64:
2981 rajveer 13140 
          self.userId = iprot.readI64();
130 ashish 13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      elif fid == 2:
559 chandransh 13144 
        if ftype == TType.I64:
2981 rajveer 13145 
          self.itemId = iprot.readI64();
559 chandransh 13146 
        else:
13147 
          iprot.skip(ftype)
130 ashish 13148 
      else:
13149 
        iprot.skip(ftype)
13150 
      iprot.readFieldEnd()
13151 
    iprot.readStructEnd()
13152 
 
13153 
  def write(self, oprot):
13154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13156 
      return
2981 rajveer 13157 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13158 
    if self.userId is not None:
2981 rajveer 13159 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13160 
      oprot.writeI64(self.userId)
130 ashish 13161 
      oprot.writeFieldEnd()
3431 rajveer 13162 
    if self.itemId is not None:
2981 rajveer 13163 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13164 
      oprot.writeI64(self.itemId)
130 ashish 13165 
      oprot.writeFieldEnd()
13166 
    oprot.writeFieldStop()
13167 
    oprot.writeStructEnd()
13168 
 
3431 rajveer 13169 
  def validate(self):
13170 
    return
13171 
 
13172 
 
130 ashish 13173 
  def __repr__(self):
13174 
    L = ['%s=%r' % (key, value)
13175 
      for key, value in self.__dict__.iteritems()]
13176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13177 
 
13178 
  def __eq__(self, other):
13179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13180 
 
13181 
  def __ne__(self, other):
13182 
    return not (self == other)
13183 
 
2981 rajveer 13184 
class updateMyResearch_result:
13185 
  """
13186 
  Attributes:
13187 
   - success
13188 
   - scx
13189 
  """
559 chandransh 13190 
 
13191 
  thrift_spec = (
2981 rajveer 13192 
    (0, TType.BOOL, 'success', None, None, ), # 0
13193 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13194 
  )
13195 
 
2981 rajveer 13196 
  def __init__(self, success=None, scx=None,):
13197 
    self.success = success
13198 
    self.scx = scx
13199 
 
559 chandransh 13200 
  def read(self, iprot):
13201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13203 
      return
13204 
    iprot.readStructBegin()
13205 
    while True:
13206 
      (fname, ftype, fid) = iprot.readFieldBegin()
13207 
      if ftype == TType.STOP:
13208 
        break
2981 rajveer 13209 
      if fid == 0:
13210 
        if ftype == TType.BOOL:
13211 
          self.success = iprot.readBool();
13212 
        else:
13213 
          iprot.skip(ftype)
13214 
      elif fid == 1:
13215 
        if ftype == TType.STRUCT:
13216 
          self.scx = WidgetException()
13217 
          self.scx.read(iprot)
13218 
        else:
13219 
          iprot.skip(ftype)
559 chandransh 13220 
      else:
13221 
        iprot.skip(ftype)
13222 
      iprot.readFieldEnd()
13223 
    iprot.readStructEnd()
13224 
 
13225 
  def write(self, oprot):
13226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13228 
      return
2981 rajveer 13229 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13230 
    if self.success is not None:
2981 rajveer 13231 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13232 
      oprot.writeBool(self.success)
13233 
      oprot.writeFieldEnd()
3431 rajveer 13234 
    if self.scx is not None:
2981 rajveer 13235 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13236 
      self.scx.write(oprot)
13237 
      oprot.writeFieldEnd()
559 chandransh 13238 
    oprot.writeFieldStop()
13239 
    oprot.writeStructEnd()
13240 
 
3431 rajveer 13241 
  def validate(self):
13242 
    return
13243 
 
13244 
 
559 chandransh 13245 
  def __repr__(self):
13246 
    L = ['%s=%r' % (key, value)
13247 
      for key, value in self.__dict__.iteritems()]
13248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13249 
 
13250 
  def __eq__(self, other):
13251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13252 
 
13253 
  def __ne__(self, other):
13254 
    return not (self == other)
13255 
 
2981 rajveer 13256 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13257 
  """
13258 
  Attributes:
2981 rajveer 13259 
   - userId
13260 
   - itemId
1596 ankur.sing 13261 
  """
559 chandransh 13262 
 
1596 ankur.sing 13263 
  thrift_spec = (
13264 
    None, # 0
2981 rajveer 13265 
    (1, TType.I64, 'userId', None, None, ), # 1
13266 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13267 
  )
13268 
 
2981 rajveer 13269 
  def __init__(self, userId=None, itemId=None,):
13270 
    self.userId = userId
13271 
    self.itemId = itemId
1596 ankur.sing 13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 1:
2981 rajveer 13283 
        if ftype == TType.I64:
13284 
          self.userId = iprot.readI64();
1596 ankur.sing 13285 
        else:
13286 
          iprot.skip(ftype)
2981 rajveer 13287 
      elif fid == 2:
13288 
        if ftype == TType.I64:
13289 
          self.itemId = iprot.readI64();
13290 
        else:
13291 
          iprot.skip(ftype)
1596 ankur.sing 13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
2981 rajveer 13301 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13302 
    if self.userId is not None:
2981 rajveer 13303 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13304 
      oprot.writeI64(self.userId)
1596 ankur.sing 13305 
      oprot.writeFieldEnd()
3431 rajveer 13306 
    if self.itemId is not None:
2981 rajveer 13307 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13308 
      oprot.writeI64(self.itemId)
13309 
      oprot.writeFieldEnd()
1596 ankur.sing 13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
3431 rajveer 13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
1596 ankur.sing 13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
2981 rajveer 13328 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13329 
  """
13330 
  Attributes:
2981 rajveer 13331 
   - scx
1596 ankur.sing 13332 
  """
13333 
 
13334 
  thrift_spec = (
2981 rajveer 13335 
    None, # 0
13336 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13337 
  )
13338 
 
2981 rajveer 13339 
  def __init__(self, scx=None,):
13340 
    self.scx = scx
1596 ankur.sing 13341 
 
13342 
  def read(self, iprot):
13343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13345 
      return
13346 
    iprot.readStructBegin()
13347 
    while True:
13348 
      (fname, ftype, fid) = iprot.readFieldBegin()
13349 
      if ftype == TType.STOP:
13350 
        break
2981 rajveer 13351 
      if fid == 1:
13352 
        if ftype == TType.STRUCT:
13353 
          self.scx = WidgetException()
13354 
          self.scx.read(iprot)
1596 ankur.sing 13355 
        else:
13356 
          iprot.skip(ftype)
13357 
      else:
13358 
        iprot.skip(ftype)
13359 
      iprot.readFieldEnd()
13360 
    iprot.readStructEnd()
13361 
 
13362 
  def write(self, oprot):
13363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13365 
      return
2981 rajveer 13366 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13367 
    if self.scx is not None:
2981 rajveer 13368 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13369 
      self.scx.write(oprot)
1596 ankur.sing 13370 
      oprot.writeFieldEnd()
13371 
    oprot.writeFieldStop()
13372 
    oprot.writeStructEnd()
13373 
 
3431 rajveer 13374 
  def validate(self):
13375 
    return
13376 
 
13377 
 
1596 ankur.sing 13378 
  def __repr__(self):
13379 
    L = ['%s=%r' % (key, value)
13380 
      for key, value in self.__dict__.iteritems()]
13381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13382 
 
13383 
  def __eq__(self, other):
13384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13385 
 
13386 
  def __ne__(self, other):
13387 
    return not (self == other)
13388 
 
2981 rajveer 13389 
class getBrowseHistoryItems_args:
1673 ankur.sing 13390 
  """
13391 
  Attributes:
2981 rajveer 13392 
   - userId
1673 ankur.sing 13393 
  """
1596 ankur.sing 13394 
 
1673 ankur.sing 13395 
  thrift_spec = (
13396 
    None, # 0
2981 rajveer 13397 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13398 
  )
13399 
 
2981 rajveer 13400 
  def __init__(self, userId=None,):
13401 
    self.userId = userId
1673 ankur.sing 13402 
 
13403 
  def read(self, iprot):
13404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13406 
      return
13407 
    iprot.readStructBegin()
13408 
    while True:
13409 
      (fname, ftype, fid) = iprot.readFieldBegin()
13410 
      if ftype == TType.STOP:
13411 
        break
13412 
      if fid == 1:
1891 ankur.sing 13413 
        if ftype == TType.I64:
2981 rajveer 13414 
          self.userId = iprot.readI64();
1891 ankur.sing 13415 
        else:
13416 
          iprot.skip(ftype)
1673 ankur.sing 13417 
      else:
13418 
        iprot.skip(ftype)
13419 
      iprot.readFieldEnd()
13420 
    iprot.readStructEnd()
13421 
 
13422 
  def write(self, oprot):
13423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13425 
      return
2981 rajveer 13426 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13427 
    if self.userId is not None:
2981 rajveer 13428 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13429 
      oprot.writeI64(self.userId)
1673 ankur.sing 13430 
      oprot.writeFieldEnd()
13431 
    oprot.writeFieldStop()
13432 
    oprot.writeStructEnd()
13433 
 
3431 rajveer 13434 
  def validate(self):
13435 
    return
13436 
 
13437 
 
1673 ankur.sing 13438 
  def __repr__(self):
13439 
    L = ['%s=%r' % (key, value)
13440 
      for key, value in self.__dict__.iteritems()]
13441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13442 
 
13443 
  def __eq__(self, other):
13444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13445 
 
13446 
  def __ne__(self, other):
13447 
    return not (self == other)
13448 
 
2981 rajveer 13449 
class getBrowseHistoryItems_result:
1673 ankur.sing 13450 
  """
13451 
  Attributes:
13452 
   - success
2981 rajveer 13453 
   - scx
1673 ankur.sing 13454 
  """
13455 
 
13456 
  thrift_spec = (
2981 rajveer 13457 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13458 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13459 
  )
13460 
 
2981 rajveer 13461 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13462 
    self.success = success
2981 rajveer 13463 
    self.scx = scx
1673 ankur.sing 13464 
 
13465 
  def read(self, iprot):
13466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13468 
      return
13469 
    iprot.readStructBegin()
13470 
    while True:
13471 
      (fname, ftype, fid) = iprot.readFieldBegin()
13472 
      if ftype == TType.STOP:
13473 
        break
13474 
      if fid == 0:
13475 
        if ftype == TType.LIST:
13476 
          self.success = []
11980 amit.gupta 13477 
          (_etype207, _size204) = iprot.readListBegin()
13478 
          for _i208 in xrange(_size204):
13479 
            _elem209 = iprot.readI64();
13480 
            self.success.append(_elem209)
1673 ankur.sing 13481 
          iprot.readListEnd()
13482 
        else:
13483 
          iprot.skip(ftype)
2981 rajveer 13484 
      elif fid == 1:
13485 
        if ftype == TType.STRUCT:
13486 
          self.scx = WidgetException()
13487 
          self.scx.read(iprot)
13488 
        else:
13489 
          iprot.skip(ftype)
1673 ankur.sing 13490 
      else:
13491 
        iprot.skip(ftype)
13492 
      iprot.readFieldEnd()
13493 
    iprot.readStructEnd()
13494 
 
13495 
  def write(self, oprot):
13496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13498 
      return
2981 rajveer 13499 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13500 
    if self.success is not None:
1673 ankur.sing 13501 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13502 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13503 
      for iter210 in self.success:
13504 
        oprot.writeI64(iter210)
1673 ankur.sing 13505 
      oprot.writeListEnd()
13506 
      oprot.writeFieldEnd()
3431 rajveer 13507 
    if self.scx is not None:
2981 rajveer 13508 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13509 
      self.scx.write(oprot)
2642 varun.gupt 13510 
      oprot.writeFieldEnd()
13511 
    oprot.writeFieldStop()
13512 
    oprot.writeStructEnd()
13513 
 
3431 rajveer 13514 
  def validate(self):
13515 
    return
13516 
 
13517 
 
2642 varun.gupt 13518 
  def __repr__(self):
13519 
    L = ['%s=%r' % (key, value)
13520 
      for key, value in self.__dict__.iteritems()]
13521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13522 
 
13523 
  def __eq__(self, other):
13524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13525 
 
13526 
  def __ne__(self, other):
13527 
    return not (self == other)
13528 
 
2981 rajveer 13529 
class updateBrowseHistory_args:
2642 varun.gupt 13530 
  """
13531 
  Attributes:
2981 rajveer 13532 
   - userId
13533 
   - itemId
2642 varun.gupt 13534 
  """
13535 
 
13536 
  thrift_spec = (
13537 
    None, # 0
2981 rajveer 13538 
    (1, TType.I64, 'userId', None, None, ), # 1
13539 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13540 
  )
13541 
 
2981 rajveer 13542 
  def __init__(self, userId=None, itemId=None,):
13543 
    self.userId = userId
13544 
    self.itemId = itemId
2642 varun.gupt 13545 
 
13546 
  def read(self, iprot):
13547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13549 
      return
13550 
    iprot.readStructBegin()
13551 
    while True:
13552 
      (fname, ftype, fid) = iprot.readFieldBegin()
13553 
      if ftype == TType.STOP:
13554 
        break
13555 
      if fid == 1:
13556 
        if ftype == TType.I64:
2981 rajveer 13557 
          self.userId = iprot.readI64();
2642 varun.gupt 13558 
        else:
13559 
          iprot.skip(ftype)
13560 
      elif fid == 2:
13561 
        if ftype == TType.I64:
2981 rajveer 13562 
          self.itemId = iprot.readI64();
2642 varun.gupt 13563 
        else:
13564 
          iprot.skip(ftype)
13565 
      else:
13566 
        iprot.skip(ftype)
13567 
      iprot.readFieldEnd()
13568 
    iprot.readStructEnd()
13569 
 
13570 
  def write(self, oprot):
13571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13573 
      return
2981 rajveer 13574 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13575 
    if self.userId is not None:
2981 rajveer 13576 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13577 
      oprot.writeI64(self.userId)
2642 varun.gupt 13578 
      oprot.writeFieldEnd()
3431 rajveer 13579 
    if self.itemId is not None:
2981 rajveer 13580 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13581 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13582 
      oprot.writeFieldEnd()
13583 
    oprot.writeFieldStop()
13584 
    oprot.writeStructEnd()
13585 
 
3431 rajveer 13586 
  def validate(self):
13587 
    return
13588 
 
13589 
 
2642 varun.gupt 13590 
  def __repr__(self):
13591 
    L = ['%s=%r' % (key, value)
13592 
      for key, value in self.__dict__.iteritems()]
13593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13594 
 
13595 
  def __eq__(self, other):
13596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13597 
 
13598 
  def __ne__(self, other):
13599 
    return not (self == other)
13600 
 
2981 rajveer 13601 
class updateBrowseHistory_result:
2642 varun.gupt 13602 
 
13603 
  thrift_spec = (
13604 
  )
13605 
 
13606 
  def read(self, iprot):
13607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13609 
      return
13610 
    iprot.readStructBegin()
13611 
    while True:
13612 
      (fname, ftype, fid) = iprot.readFieldBegin()
13613 
      if ftype == TType.STOP:
13614 
        break
13615 
      else:
13616 
        iprot.skip(ftype)
13617 
      iprot.readFieldEnd()
13618 
    iprot.readStructEnd()
13619 
 
13620 
  def write(self, oprot):
13621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13623 
      return
2981 rajveer 13624 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13625 
    oprot.writeFieldStop()
13626 
    oprot.writeStructEnd()
13627 
 
3431 rajveer 13628 
  def validate(self):
13629 
    return
13630 
 
13631 
 
2642 varun.gupt 13632 
  def __repr__(self):
13633 
    L = ['%s=%r' % (key, value)
13634 
      for key, value in self.__dict__.iteritems()]
13635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13636 
 
13637 
  def __eq__(self, other):
13638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13639 
 
13640 
  def __ne__(self, other):
13641 
    return not (self == other)
13642 
 
3385 varun.gupt 13643 
class getCartsWithCouponCount_args:
13644 
  """
13645 
  Attributes:
13646 
   - couponCode
13647 
  """
2642 varun.gupt 13648 
 
3385 varun.gupt 13649 
  thrift_spec = (
13650 
    None, # 0
13651 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13652 
  )
13653 
 
13654 
  def __init__(self, couponCode=None,):
13655 
    self.couponCode = couponCode
13656 
 
13657 
  def read(self, iprot):
13658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13660 
      return
13661 
    iprot.readStructBegin()
13662 
    while True:
13663 
      (fname, ftype, fid) = iprot.readFieldBegin()
13664 
      if ftype == TType.STOP:
13665 
        break
13666 
      if fid == 1:
13667 
        if ftype == TType.STRING:
13668 
          self.couponCode = iprot.readString();
13669 
        else:
13670 
          iprot.skip(ftype)
13671 
      else:
13672 
        iprot.skip(ftype)
13673 
      iprot.readFieldEnd()
13674 
    iprot.readStructEnd()
13675 
 
13676 
  def write(self, oprot):
13677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13679 
      return
13680 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13681 
    if self.couponCode is not None:
3385 varun.gupt 13682 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13683 
      oprot.writeString(self.couponCode)
13684 
      oprot.writeFieldEnd()
13685 
    oprot.writeFieldStop()
13686 
    oprot.writeStructEnd()
13687 
 
3431 rajveer 13688 
  def validate(self):
13689 
    return
13690 
 
13691 
 
3385 varun.gupt 13692 
  def __repr__(self):
13693 
    L = ['%s=%r' % (key, value)
13694 
      for key, value in self.__dict__.iteritems()]
13695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13696 
 
13697 
  def __eq__(self, other):
13698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13699 
 
13700 
  def __ne__(self, other):
13701 
    return not (self == other)
13702 
 
13703 
class getCartsWithCouponCount_result:
13704 
  """
13705 
  Attributes:
13706 
   - success
13707 
  """
13708 
 
13709 
  thrift_spec = (
13710 
    (0, TType.I64, 'success', None, None, ), # 0
13711 
  )
13712 
 
13713 
  def __init__(self, success=None,):
13714 
    self.success = success
13715 
 
13716 
  def read(self, iprot):
13717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13719 
      return
13720 
    iprot.readStructBegin()
13721 
    while True:
13722 
      (fname, ftype, fid) = iprot.readFieldBegin()
13723 
      if ftype == TType.STOP:
13724 
        break
13725 
      if fid == 0:
13726 
        if ftype == TType.I64:
13727 
          self.success = iprot.readI64();
13728 
        else:
13729 
          iprot.skip(ftype)
13730 
      else:
13731 
        iprot.skip(ftype)
13732 
      iprot.readFieldEnd()
13733 
    iprot.readStructEnd()
13734 
 
13735 
  def write(self, oprot):
13736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13738 
      return
13739 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13740 
    if self.success is not None:
3385 varun.gupt 13741 
      oprot.writeFieldBegin('success', TType.I64, 0)
13742 
      oprot.writeI64(self.success)
13743 
      oprot.writeFieldEnd()
13744 
    oprot.writeFieldStop()
13745 
    oprot.writeStructEnd()
13746 
 
3431 rajveer 13747 
  def validate(self):
13748 
    return
13749 
 
13750 
 
3385 varun.gupt 13751 
  def __repr__(self):
13752 
    L = ['%s=%r' % (key, value)
13753 
      for key, value in self.__dict__.iteritems()]
13754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13755 
 
13756 
  def __eq__(self, other):
13757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13758 
 
13759 
  def __ne__(self, other):
13760 
    return not (self == other)
3499 mandeep.dh 13761 
 
13762 
class increaseTrustLevel_args:
13763 
  """
13764 
  Attributes:
13765 
   - userId
13766 
   - trustLevelDelta
13767 
  """
13768 
 
13769 
  thrift_spec = (
13770 
    None, # 0
13771 
    (1, TType.I64, 'userId', None, None, ), # 1
13772 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13773 
  )
13774 
 
13775 
  def __init__(self, userId=None, trustLevelDelta=None,):
13776 
    self.userId = userId
13777 
    self.trustLevelDelta = trustLevelDelta
13778 
 
13779 
  def read(self, iprot):
13780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13782 
      return
13783 
    iprot.readStructBegin()
13784 
    while True:
13785 
      (fname, ftype, fid) = iprot.readFieldBegin()
13786 
      if ftype == TType.STOP:
13787 
        break
13788 
      if fid == 1:
13789 
        if ftype == TType.I64:
13790 
          self.userId = iprot.readI64();
13791 
        else:
13792 
          iprot.skip(ftype)
13793 
      elif fid == 2:
13794 
        if ftype == TType.DOUBLE:
13795 
          self.trustLevelDelta = iprot.readDouble();
13796 
        else:
13797 
          iprot.skip(ftype)
13798 
      else:
13799 
        iprot.skip(ftype)
13800 
      iprot.readFieldEnd()
13801 
    iprot.readStructEnd()
13802 
 
13803 
  def write(self, oprot):
13804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13806 
      return
13807 
    oprot.writeStructBegin('increaseTrustLevel_args')
13808 
    if self.userId is not None:
13809 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13810 
      oprot.writeI64(self.userId)
13811 
      oprot.writeFieldEnd()
13812 
    if self.trustLevelDelta is not None:
13813 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13814 
      oprot.writeDouble(self.trustLevelDelta)
13815 
      oprot.writeFieldEnd()
13816 
    oprot.writeFieldStop()
13817 
    oprot.writeStructEnd()
13818 
 
13819 
  def validate(self):
13820 
    return
13821 
 
13822 
 
13823 
  def __repr__(self):
13824 
    L = ['%s=%r' % (key, value)
13825 
      for key, value in self.__dict__.iteritems()]
13826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13827 
 
13828 
  def __eq__(self, other):
13829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13830 
 
13831 
  def __ne__(self, other):
13832 
    return not (self == other)
4668 varun.gupt 13833 
 
5407 amar.kumar 13834 
class getTrustLevel_args:
13835 
  """
13836 
  Attributes:
13837 
   - userId
13838 
  """
13839 
 
13840 
  thrift_spec = (
13841 
    None, # 0
13842 
    (1, TType.I64, 'userId', None, None, ), # 1
13843 
  )
13844 
 
13845 
  def __init__(self, userId=None,):
13846 
    self.userId = userId
13847 
 
13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
13857 
      if fid == 1:
13858 
        if ftype == TType.I64:
13859 
          self.userId = iprot.readI64();
13860 
        else:
13861 
          iprot.skip(ftype)
13862 
      else:
13863 
        iprot.skip(ftype)
13864 
      iprot.readFieldEnd()
13865 
    iprot.readStructEnd()
13866 
 
13867 
  def write(self, oprot):
13868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13870 
      return
13871 
    oprot.writeStructBegin('getTrustLevel_args')
13872 
    if self.userId is not None:
13873 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13874 
      oprot.writeI64(self.userId)
13875 
      oprot.writeFieldEnd()
13876 
    oprot.writeFieldStop()
13877 
    oprot.writeStructEnd()
13878 
 
13879 
  def validate(self):
13880 
    return
13881 
 
13882 
 
13883 
  def __repr__(self):
13884 
    L = ['%s=%r' % (key, value)
13885 
      for key, value in self.__dict__.iteritems()]
13886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13887 
 
13888 
  def __eq__(self, other):
13889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13890 
 
13891 
  def __ne__(self, other):
13892 
    return not (self == other)
13893 
 
13894 
class getTrustLevel_result:
13895 
  """
13896 
  Attributes:
13897 
   - success
13898 
  """
13899 
 
13900 
  thrift_spec = (
13901 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13902 
  )
13903 
 
13904 
  def __init__(self, success=None,):
13905 
    self.success = success
13906 
 
13907 
  def read(self, iprot):
13908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13910 
      return
13911 
    iprot.readStructBegin()
13912 
    while True:
13913 
      (fname, ftype, fid) = iprot.readFieldBegin()
13914 
      if ftype == TType.STOP:
13915 
        break
13916 
      if fid == 0:
13917 
        if ftype == TType.DOUBLE:
13918 
          self.success = iprot.readDouble();
13919 
        else:
13920 
          iprot.skip(ftype)
13921 
      else:
13922 
        iprot.skip(ftype)
13923 
      iprot.readFieldEnd()
13924 
    iprot.readStructEnd()
13925 
 
13926 
  def write(self, oprot):
13927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13929 
      return
13930 
    oprot.writeStructBegin('getTrustLevel_result')
13931 
    if self.success is not None:
13932 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13933 
      oprot.writeDouble(self.success)
13934 
      oprot.writeFieldEnd()
13935 
    oprot.writeFieldStop()
13936 
    oprot.writeStructEnd()
13937 
 
13938 
  def validate(self):
13939 
    return
13940 
 
13941 
 
13942 
  def __repr__(self):
13943 
    L = ['%s=%r' % (key, value)
13944 
      for key, value in self.__dict__.iteritems()]
13945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13946 
 
13947 
  def __eq__(self, other):
13948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13949 
 
13950 
  def __ne__(self, other):
13951 
    return not (self == other)
13952 
 
4668 varun.gupt 13953 
class showCODOption_args:
13954 
  """
13955 
  Attributes:
13956 
   - cartId
13957 
   - sourceId
13958 
   - pincode
13959 
  """
13960 
 
13961 
  thrift_spec = (
13962 
    None, # 0
13963 
    (1, TType.I64, 'cartId', None, None, ), # 1
13964 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13965 
    (3, TType.STRING, 'pincode', None, None, ), # 3
13966 
  )
13967 
 
13968 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
13969 
    self.cartId = cartId
13970 
    self.sourceId = sourceId
13971 
    self.pincode = pincode
13972 
 
13973 
  def read(self, iprot):
13974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13976 
      return
13977 
    iprot.readStructBegin()
13978 
    while True:
13979 
      (fname, ftype, fid) = iprot.readFieldBegin()
13980 
      if ftype == TType.STOP:
13981 
        break
13982 
      if fid == 1:
13983 
        if ftype == TType.I64:
13984 
          self.cartId = iprot.readI64();
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      elif fid == 2:
13988 
        if ftype == TType.I64:
13989 
          self.sourceId = iprot.readI64();
13990 
        else:
13991 
          iprot.skip(ftype)
13992 
      elif fid == 3:
13993 
        if ftype == TType.STRING:
13994 
          self.pincode = iprot.readString();
13995 
        else:
13996 
          iprot.skip(ftype)
13997 
      else:
13998 
        iprot.skip(ftype)
13999 
      iprot.readFieldEnd()
14000 
    iprot.readStructEnd()
14001 
 
14002 
  def write(self, oprot):
14003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14005 
      return
14006 
    oprot.writeStructBegin('showCODOption_args')
14007 
    if self.cartId is not None:
14008 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14009 
      oprot.writeI64(self.cartId)
14010 
      oprot.writeFieldEnd()
14011 
    if self.sourceId is not None:
14012 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14013 
      oprot.writeI64(self.sourceId)
14014 
      oprot.writeFieldEnd()
14015 
    if self.pincode is not None:
14016 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14017 
      oprot.writeString(self.pincode)
14018 
      oprot.writeFieldEnd()
14019 
    oprot.writeFieldStop()
14020 
    oprot.writeStructEnd()
14021 
 
14022 
  def validate(self):
14023 
    return
14024 
 
14025 
 
14026 
  def __repr__(self):
14027 
    L = ['%s=%r' % (key, value)
14028 
      for key, value in self.__dict__.iteritems()]
14029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14030 
 
14031 
  def __eq__(self, other):
14032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14033 
 
14034 
  def __ne__(self, other):
14035 
    return not (self == other)
14036 
 
14037 
class showCODOption_result:
14038 
  """
14039 
  Attributes:
14040 
   - success
14041 
  """
14042 
 
14043 
  thrift_spec = (
14044 
    (0, TType.BOOL, 'success', None, None, ), # 0
14045 
  )
14046 
 
14047 
  def __init__(self, success=None,):
14048 
    self.success = success
14049 
 
14050 
  def read(self, iprot):
14051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14053 
      return
14054 
    iprot.readStructBegin()
14055 
    while True:
14056 
      (fname, ftype, fid) = iprot.readFieldBegin()
14057 
      if ftype == TType.STOP:
14058 
        break
14059 
      if fid == 0:
14060 
        if ftype == TType.BOOL:
14061 
          self.success = iprot.readBool();
14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      else:
14065 
        iprot.skip(ftype)
14066 
      iprot.readFieldEnd()
14067 
    iprot.readStructEnd()
14068 
 
14069 
  def write(self, oprot):
14070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14072 
      return
14073 
    oprot.writeStructBegin('showCODOption_result')
14074 
    if self.success is not None:
14075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14076 
      oprot.writeBool(self.success)
14077 
      oprot.writeFieldEnd()
14078 
    oprot.writeFieldStop()
14079 
    oprot.writeStructEnd()
14080 
 
14081 
  def validate(self):
14082 
    return
14083 
 
14084 
 
14085 
  def __repr__(self):
14086 
    L = ['%s=%r' % (key, value)
14087 
      for key, value in self.__dict__.iteritems()]
14088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14089 
 
14090 
  def __eq__(self, other):
14091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14092 
 
14093 
  def __ne__(self, other):
14094 
    return not (self == other)
5623 anupam.sin 14095 
 
14096 
class getUserEmails_args:
14097 
  """
14098 
  Attributes:
14099 
   - startDate
14100 
   - endDate
14101 
  """
14102 
 
14103 
  thrift_spec = (
14104 
    None, # 0
14105 
    (1, TType.I64, 'startDate', None, None, ), # 1
14106 
    (2, TType.I64, 'endDate', None, None, ), # 2
14107 
  )
14108 
 
14109 
  def __init__(self, startDate=None, endDate=None,):
14110 
    self.startDate = startDate
14111 
    self.endDate = endDate
14112 
 
14113 
  def read(self, iprot):
14114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14116 
      return
14117 
    iprot.readStructBegin()
14118 
    while True:
14119 
      (fname, ftype, fid) = iprot.readFieldBegin()
14120 
      if ftype == TType.STOP:
14121 
        break
14122 
      if fid == 1:
14123 
        if ftype == TType.I64:
14124 
          self.startDate = iprot.readI64();
14125 
        else:
14126 
          iprot.skip(ftype)
14127 
      elif fid == 2:
14128 
        if ftype == TType.I64:
14129 
          self.endDate = iprot.readI64();
14130 
        else:
14131 
          iprot.skip(ftype)
14132 
      else:
14133 
        iprot.skip(ftype)
14134 
      iprot.readFieldEnd()
14135 
    iprot.readStructEnd()
14136 
 
14137 
  def write(self, oprot):
14138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14140 
      return
14141 
    oprot.writeStructBegin('getUserEmails_args')
14142 
    if self.startDate is not None:
14143 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14144 
      oprot.writeI64(self.startDate)
14145 
      oprot.writeFieldEnd()
14146 
    if self.endDate is not None:
14147 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14148 
      oprot.writeI64(self.endDate)
14149 
      oprot.writeFieldEnd()
14150 
    oprot.writeFieldStop()
14151 
    oprot.writeStructEnd()
14152 
 
14153 
  def validate(self):
14154 
    return
14155 
 
14156 
 
14157 
  def __repr__(self):
14158 
    L = ['%s=%r' % (key, value)
14159 
      for key, value in self.__dict__.iteritems()]
14160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14161 
 
14162 
  def __eq__(self, other):
14163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14164 
 
14165 
  def __ne__(self, other):
14166 
    return not (self == other)
14167 
 
14168 
class getUserEmails_result:
14169 
  """
14170 
  Attributes:
14171 
   - success
14172 
  """
14173 
 
14174 
  thrift_spec = (
14175 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14176 
  )
14177 
 
14178 
  def __init__(self, success=None,):
14179 
    self.success = success
14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      if fid == 0:
14191 
        if ftype == TType.LIST:
14192 
          self.success = []
11980 amit.gupta 14193 
          (_etype214, _size211) = iprot.readListBegin()
14194 
          for _i215 in xrange(_size211):
14195 
            _elem216 = iprot.readString();
14196 
            self.success.append(_elem216)
5623 anupam.sin 14197 
          iprot.readListEnd()
14198 
        else:
14199 
          iprot.skip(ftype)
14200 
      else:
14201 
        iprot.skip(ftype)
14202 
      iprot.readFieldEnd()
14203 
    iprot.readStructEnd()
14204 
 
14205 
  def write(self, oprot):
14206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14208 
      return
14209 
    oprot.writeStructBegin('getUserEmails_result')
14210 
    if self.success is not None:
14211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14212 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14213 
      for iter217 in self.success:
14214 
        oprot.writeString(iter217)
5623 anupam.sin 14215 
      oprot.writeListEnd()
14216 
      oprot.writeFieldEnd()
14217 
    oprot.writeFieldStop()
14218 
    oprot.writeStructEnd()
14219 
 
14220 
  def validate(self):
14221 
    return
14222 
 
14223 
 
14224 
  def __repr__(self):
14225 
    L = ['%s=%r' % (key, value)
14226 
      for key, value in self.__dict__.iteritems()]
14227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14228 
 
14229 
  def __eq__(self, other):
14230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14231 
 
14232 
  def __ne__(self, other):
14233 
    return not (self == other)
6821 amar.kumar 14234 
 
6903 anupam.sin 14235 
class insureItem_args:
14236 
  """
14237 
  Attributes:
14238 
   - itemId
14239 
   - cartId
14240 
   - toInsure
9299 kshitij.so 14241 
   - insurerType
6903 anupam.sin 14242 
  """
14243 
 
14244 
  thrift_spec = (
14245 
    None, # 0
14246 
    (1, TType.I64, 'itemId', None, None, ), # 1
14247 
    (2, TType.I64, 'cartId', None, None, ), # 2
14248 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14249 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14250 
  )
14251 
 
9299 kshitij.so 14252 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14253 
    self.itemId = itemId
14254 
    self.cartId = cartId
14255 
    self.toInsure = toInsure
9299 kshitij.so 14256 
    self.insurerType = insurerType
6903 anupam.sin 14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 1:
14268 
        if ftype == TType.I64:
14269 
          self.itemId = iprot.readI64();
14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      elif fid == 2:
14273 
        if ftype == TType.I64:
14274 
          self.cartId = iprot.readI64();
14275 
        else:
14276 
          iprot.skip(ftype)
14277 
      elif fid == 3:
14278 
        if ftype == TType.BOOL:
14279 
          self.toInsure = iprot.readBool();
14280 
        else:
14281 
          iprot.skip(ftype)
9299 kshitij.so 14282 
      elif fid == 4:
14283 
        if ftype == TType.I32:
14284 
          self.insurerType = iprot.readI32();
14285 
        else:
14286 
          iprot.skip(ftype)
6903 anupam.sin 14287 
      else:
14288 
        iprot.skip(ftype)
14289 
      iprot.readFieldEnd()
14290 
    iprot.readStructEnd()
14291 
 
14292 
  def write(self, oprot):
14293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14295 
      return
14296 
    oprot.writeStructBegin('insureItem_args')
14297 
    if self.itemId is not None:
14298 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14299 
      oprot.writeI64(self.itemId)
14300 
      oprot.writeFieldEnd()
14301 
    if self.cartId is not None:
14302 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14303 
      oprot.writeI64(self.cartId)
14304 
      oprot.writeFieldEnd()
14305 
    if self.toInsure is not None:
14306 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14307 
      oprot.writeBool(self.toInsure)
14308 
      oprot.writeFieldEnd()
9299 kshitij.so 14309 
    if self.insurerType is not None:
14310 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14311 
      oprot.writeI32(self.insurerType)
14312 
      oprot.writeFieldEnd()
6903 anupam.sin 14313 
    oprot.writeFieldStop()
14314 
    oprot.writeStructEnd()
14315 
 
14316 
  def validate(self):
14317 
    return
14318 
 
14319 
 
14320 
  def __repr__(self):
14321 
    L = ['%s=%r' % (key, value)
14322 
      for key, value in self.__dict__.iteritems()]
14323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14324 
 
14325 
  def __eq__(self, other):
14326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14327 
 
14328 
  def __ne__(self, other):
14329 
    return not (self == other)
14330 
 
14331 
class insureItem_result:
14332 
  """
14333 
  Attributes:
14334 
   - success
14335 
  """
14336 
 
14337 
  thrift_spec = (
14338 
    (0, TType.BOOL, 'success', None, None, ), # 0
14339 
  )
14340 
 
14341 
  def __init__(self, success=None,):
14342 
    self.success = success
14343 
 
14344 
  def read(self, iprot):
14345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14347 
      return
14348 
    iprot.readStructBegin()
14349 
    while True:
14350 
      (fname, ftype, fid) = iprot.readFieldBegin()
14351 
      if ftype == TType.STOP:
14352 
        break
14353 
      if fid == 0:
14354 
        if ftype == TType.BOOL:
14355 
          self.success = iprot.readBool();
14356 
        else:
14357 
          iprot.skip(ftype)
14358 
      else:
14359 
        iprot.skip(ftype)
14360 
      iprot.readFieldEnd()
14361 
    iprot.readStructEnd()
14362 
 
14363 
  def write(self, oprot):
14364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14366 
      return
14367 
    oprot.writeStructBegin('insureItem_result')
14368 
    if self.success is not None:
14369 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14370 
      oprot.writeBool(self.success)
14371 
      oprot.writeFieldEnd()
14372 
    oprot.writeFieldStop()
14373 
    oprot.writeStructEnd()
14374 
 
14375 
  def validate(self):
14376 
    return
14377 
 
14378 
 
14379 
  def __repr__(self):
14380 
    L = ['%s=%r' % (key, value)
14381 
      for key, value in self.__dict__.iteritems()]
14382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14383 
 
14384 
  def __eq__(self, other):
14385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14386 
 
14387 
  def __ne__(self, other):
14388 
    return not (self == other)
14389 
 
14390 
class cancelInsurance_args:
14391 
  """
14392 
  Attributes:
14393 
   - cartId
14394 
  """
14395 
 
14396 
  thrift_spec = (
14397 
    None, # 0
14398 
    (1, TType.I64, 'cartId', None, None, ), # 1
14399 
  )
14400 
 
14401 
  def __init__(self, cartId=None,):
14402 
    self.cartId = cartId
14403 
 
14404 
  def read(self, iprot):
14405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14407 
      return
14408 
    iprot.readStructBegin()
14409 
    while True:
14410 
      (fname, ftype, fid) = iprot.readFieldBegin()
14411 
      if ftype == TType.STOP:
14412 
        break
14413 
      if fid == 1:
14414 
        if ftype == TType.I64:
14415 
          self.cartId = iprot.readI64();
14416 
        else:
14417 
          iprot.skip(ftype)
14418 
      else:
14419 
        iprot.skip(ftype)
14420 
      iprot.readFieldEnd()
14421 
    iprot.readStructEnd()
14422 
 
14423 
  def write(self, oprot):
14424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14426 
      return
14427 
    oprot.writeStructBegin('cancelInsurance_args')
14428 
    if self.cartId is not None:
14429 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14430 
      oprot.writeI64(self.cartId)
14431 
      oprot.writeFieldEnd()
14432 
    oprot.writeFieldStop()
14433 
    oprot.writeStructEnd()
14434 
 
14435 
  def validate(self):
14436 
    return
14437 
 
14438 
 
14439 
  def __repr__(self):
14440 
    L = ['%s=%r' % (key, value)
14441 
      for key, value in self.__dict__.iteritems()]
14442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14443 
 
14444 
  def __eq__(self, other):
14445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14446 
 
14447 
  def __ne__(self, other):
14448 
    return not (self == other)
14449 
 
14450 
class cancelInsurance_result:
14451 
  """
14452 
  Attributes:
14453 
   - success
14454 
  """
14455 
 
14456 
  thrift_spec = (
14457 
    (0, TType.BOOL, 'success', None, None, ), # 0
14458 
  )
14459 
 
14460 
  def __init__(self, success=None,):
14461 
    self.success = success
14462 
 
14463 
  def read(self, iprot):
14464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14466 
      return
14467 
    iprot.readStructBegin()
14468 
    while True:
14469 
      (fname, ftype, fid) = iprot.readFieldBegin()
14470 
      if ftype == TType.STOP:
14471 
        break
14472 
      if fid == 0:
14473 
        if ftype == TType.BOOL:
14474 
          self.success = iprot.readBool();
14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      else:
14478 
        iprot.skip(ftype)
14479 
      iprot.readFieldEnd()
14480 
    iprot.readStructEnd()
14481 
 
14482 
  def write(self, oprot):
14483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14485 
      return
14486 
    oprot.writeStructBegin('cancelInsurance_result')
14487 
    if self.success is not None:
14488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14489 
      oprot.writeBool(self.success)
14490 
      oprot.writeFieldEnd()
14491 
    oprot.writeFieldStop()
14492 
    oprot.writeStructEnd()
14493 
 
14494 
  def validate(self):
14495 
    return
14496 
 
14497 
 
14498 
  def __repr__(self):
14499 
    L = ['%s=%r' % (key, value)
14500 
      for key, value in self.__dict__.iteritems()]
14501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14502 
 
14503 
  def __eq__(self, other):
14504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14505 
 
14506 
  def __ne__(self, other):
14507 
    return not (self == other)
14508 
 
14509 
class storeInsuranceSpecificDetails_args:
14510 
  """
14511 
  Attributes:
14512 
   - addressId
14513 
   - dob
14514 
   - guardianName
14515 
  """
14516 
 
14517 
  thrift_spec = (
14518 
    None, # 0
14519 
    (1, TType.I64, 'addressId', None, None, ), # 1
14520 
    (2, TType.STRING, 'dob', None, None, ), # 2
14521 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14522 
  )
14523 
 
14524 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14525 
    self.addressId = addressId
14526 
    self.dob = dob
14527 
    self.guardianName = guardianName
14528 
 
14529 
  def read(self, iprot):
14530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14532 
      return
14533 
    iprot.readStructBegin()
14534 
    while True:
14535 
      (fname, ftype, fid) = iprot.readFieldBegin()
14536 
      if ftype == TType.STOP:
14537 
        break
14538 
      if fid == 1:
14539 
        if ftype == TType.I64:
14540 
          self.addressId = iprot.readI64();
14541 
        else:
14542 
          iprot.skip(ftype)
14543 
      elif fid == 2:
14544 
        if ftype == TType.STRING:
14545 
          self.dob = iprot.readString();
14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      elif fid == 3:
14549 
        if ftype == TType.STRING:
14550 
          self.guardianName = iprot.readString();
14551 
        else:
14552 
          iprot.skip(ftype)
14553 
      else:
14554 
        iprot.skip(ftype)
14555 
      iprot.readFieldEnd()
14556 
    iprot.readStructEnd()
14557 
 
14558 
  def write(self, oprot):
14559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14561 
      return
14562 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14563 
    if self.addressId is not None:
14564 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14565 
      oprot.writeI64(self.addressId)
14566 
      oprot.writeFieldEnd()
14567 
    if self.dob is not None:
14568 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14569 
      oprot.writeString(self.dob)
14570 
      oprot.writeFieldEnd()
14571 
    if self.guardianName is not None:
14572 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14573 
      oprot.writeString(self.guardianName)
14574 
      oprot.writeFieldEnd()
14575 
    oprot.writeFieldStop()
14576 
    oprot.writeStructEnd()
14577 
 
14578 
  def validate(self):
14579 
    return
14580 
 
14581 
 
14582 
  def __repr__(self):
14583 
    L = ['%s=%r' % (key, value)
14584 
      for key, value in self.__dict__.iteritems()]
14585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14586 
 
14587 
  def __eq__(self, other):
14588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14589 
 
14590 
  def __ne__(self, other):
14591 
    return not (self == other)
14592 
 
14593 
class storeInsuranceSpecificDetails_result:
14594 
  """
14595 
  Attributes:
14596 
   - success
14597 
  """
14598 
 
14599 
  thrift_spec = (
14600 
    (0, TType.BOOL, 'success', None, None, ), # 0
14601 
  )
14602 
 
14603 
  def __init__(self, success=None,):
14604 
    self.success = success
14605 
 
14606 
  def read(self, iprot):
14607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14609 
      return
14610 
    iprot.readStructBegin()
14611 
    while True:
14612 
      (fname, ftype, fid) = iprot.readFieldBegin()
14613 
      if ftype == TType.STOP:
14614 
        break
14615 
      if fid == 0:
14616 
        if ftype == TType.BOOL:
14617 
          self.success = iprot.readBool();
14618 
        else:
14619 
          iprot.skip(ftype)
14620 
      else:
14621 
        iprot.skip(ftype)
14622 
      iprot.readFieldEnd()
14623 
    iprot.readStructEnd()
14624 
 
14625 
  def write(self, oprot):
14626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14628 
      return
14629 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14630 
    if self.success is not None:
14631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14632 
      oprot.writeBool(self.success)
14633 
      oprot.writeFieldEnd()
14634 
    oprot.writeFieldStop()
14635 
    oprot.writeStructEnd()
14636 
 
14637 
  def validate(self):
14638 
    return
14639 
 
14640 
 
14641 
  def __repr__(self):
14642 
    L = ['%s=%r' % (key, value)
14643 
      for key, value in self.__dict__.iteritems()]
14644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14645 
 
14646 
  def __eq__(self, other):
14647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14648 
 
14649 
  def __ne__(self, other):
14650 
    return not (self == other)
14651 
 
14652 
class isInsuranceDetailPresent_args:
14653 
  """
14654 
  Attributes:
14655 
   - addressId
14656 
  """
14657 
 
14658 
  thrift_spec = (
14659 
    None, # 0
14660 
    (1, TType.I64, 'addressId', None, None, ), # 1
14661 
  )
14662 
 
14663 
  def __init__(self, addressId=None,):
14664 
    self.addressId = addressId
14665 
 
14666 
  def read(self, iprot):
14667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14669 
      return
14670 
    iprot.readStructBegin()
14671 
    while True:
14672 
      (fname, ftype, fid) = iprot.readFieldBegin()
14673 
      if ftype == TType.STOP:
14674 
        break
14675 
      if fid == 1:
14676 
        if ftype == TType.I64:
14677 
          self.addressId = iprot.readI64();
14678 
        else:
14679 
          iprot.skip(ftype)
14680 
      else:
14681 
        iprot.skip(ftype)
14682 
      iprot.readFieldEnd()
14683 
    iprot.readStructEnd()
14684 
 
14685 
  def write(self, oprot):
14686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14688 
      return
14689 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14690 
    if self.addressId is not None:
14691 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14692 
      oprot.writeI64(self.addressId)
14693 
      oprot.writeFieldEnd()
14694 
    oprot.writeFieldStop()
14695 
    oprot.writeStructEnd()
14696 
 
14697 
  def validate(self):
14698 
    return
14699 
 
14700 
 
14701 
  def __repr__(self):
14702 
    L = ['%s=%r' % (key, value)
14703 
      for key, value in self.__dict__.iteritems()]
14704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14705 
 
14706 
  def __eq__(self, other):
14707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14708 
 
14709 
  def __ne__(self, other):
14710 
    return not (self == other)
14711 
 
14712 
class isInsuranceDetailPresent_result:
14713 
  """
14714 
  Attributes:
14715 
   - success
14716 
  """
14717 
 
14718 
  thrift_spec = (
14719 
    (0, TType.BOOL, 'success', None, None, ), # 0
14720 
  )
14721 
 
14722 
  def __init__(self, success=None,):
14723 
    self.success = success
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 0:
14735 
        if ftype == TType.BOOL:
14736 
          self.success = iprot.readBool();
14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      else:
14740 
        iprot.skip(ftype)
14741 
      iprot.readFieldEnd()
14742 
    iprot.readStructEnd()
14743 
 
14744 
  def write(self, oprot):
14745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14747 
      return
14748 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14749 
    if self.success is not None:
14750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14751 
      oprot.writeBool(self.success)
14752 
      oprot.writeFieldEnd()
14753 
    oprot.writeFieldStop()
14754 
    oprot.writeStructEnd()
14755 
 
14756 
  def validate(self):
14757 
    return
14758 
 
14759 
 
14760 
  def __repr__(self):
14761 
    L = ['%s=%r' % (key, value)
14762 
      for key, value in self.__dict__.iteritems()]
14763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14764 
 
14765 
  def __eq__(self, other):
14766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14767 
 
14768 
  def __ne__(self, other):
14769 
    return not (self == other)
14770 
 
9791 rajveer 14771 
class getProductsAddedToCart_args:
6821 amar.kumar 14772 
  """
14773 
  Attributes:
14774 
   - startDate
14775 
   - endDate
14776 
  """
14777 
 
14778 
  thrift_spec = (
14779 
    None, # 0
9791 rajveer 14780 
    (1, TType.I64, 'startDate', None, None, ), # 1
14781 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14782 
  )
14783 
 
9791 rajveer 14784 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14785 
    self.startDate = startDate
14786 
    self.endDate = endDate
14787 
 
14788 
  def read(self, iprot):
14789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14791 
      return
14792 
    iprot.readStructBegin()
14793 
    while True:
14794 
      (fname, ftype, fid) = iprot.readFieldBegin()
14795 
      if ftype == TType.STOP:
14796 
        break
14797 
      if fid == 1:
14798 
        if ftype == TType.I64:
9791 rajveer 14799 
          self.startDate = iprot.readI64();
6821 amar.kumar 14800 
        else:
14801 
          iprot.skip(ftype)
14802 
      elif fid == 2:
14803 
        if ftype == TType.I64:
14804 
          self.endDate = iprot.readI64();
14805 
        else:
14806 
          iprot.skip(ftype)
14807 
      else:
14808 
        iprot.skip(ftype)
14809 
      iprot.readFieldEnd()
14810 
    iprot.readStructEnd()
14811 
 
14812 
  def write(self, oprot):
14813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14815 
      return
9791 rajveer 14816 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14817 
    if self.startDate is not None:
9791 rajveer 14818 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14819 
      oprot.writeI64(self.startDate)
14820 
      oprot.writeFieldEnd()
14821 
    if self.endDate is not None:
9791 rajveer 14822 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14823 
      oprot.writeI64(self.endDate)
14824 
      oprot.writeFieldEnd()
14825 
    oprot.writeFieldStop()
14826 
    oprot.writeStructEnd()
14827 
 
14828 
  def validate(self):
14829 
    return
14830 
 
14831 
 
14832 
  def __repr__(self):
14833 
    L = ['%s=%r' % (key, value)
14834 
      for key, value in self.__dict__.iteritems()]
14835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14836 
 
14837 
  def __eq__(self, other):
14838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14839 
 
14840 
  def __ne__(self, other):
14841 
    return not (self == other)
14842 
 
9791 rajveer 14843 
class getProductsAddedToCart_result:
6821 amar.kumar 14844 
  """
14845 
  Attributes:
14846 
   - success
14847 
  """
14848 
 
14849 
  thrift_spec = (
9791 rajveer 14850 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14851 
  )
14852 
 
14853 
  def __init__(self, success=None,):
14854 
    self.success = success
14855 
 
14856 
  def read(self, iprot):
14857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14859 
      return
14860 
    iprot.readStructBegin()
14861 
    while True:
14862 
      (fname, ftype, fid) = iprot.readFieldBegin()
14863 
      if ftype == TType.STOP:
14864 
        break
14865 
      if fid == 0:
9791 rajveer 14866 
        if ftype == TType.LIST:
14867 
          self.success = []
11980 amit.gupta 14868 
          (_etype221, _size218) = iprot.readListBegin()
14869 
          for _i222 in xrange(_size218):
14870 
            _elem223 = iprot.readI64();
14871 
            self.success.append(_elem223)
9791 rajveer 14872 
          iprot.readListEnd()
6821 amar.kumar 14873 
        else:
14874 
          iprot.skip(ftype)
14875 
      else:
14876 
        iprot.skip(ftype)
14877 
      iprot.readFieldEnd()
14878 
    iprot.readStructEnd()
14879 
 
14880 
  def write(self, oprot):
14881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14883 
      return
9791 rajveer 14884 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14885 
    if self.success is not None:
9791 rajveer 14886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14887 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14888 
      for iter224 in self.success:
14889 
        oprot.writeI64(iter224)
9791 rajveer 14890 
      oprot.writeListEnd()
6821 amar.kumar 14891 
      oprot.writeFieldEnd()
14892 
    oprot.writeFieldStop()
14893 
    oprot.writeStructEnd()
14894 
 
14895 
  def validate(self):
14896 
    return
14897 
 
14898 
 
14899 
  def __repr__(self):
14900 
    L = ['%s=%r' % (key, value)
14901 
      for key, value in self.__dict__.iteritems()]
14902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14903 
 
14904 
  def __eq__(self, other):
14905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14906 
 
14907 
  def __ne__(self, other):
14908 
    return not (self == other)
11592 amit.gupta 14909 
 
14910 
class validateCartPlus_args:
14911 
  """
14912 
  Attributes:
14913 
   - cartId
14914 
   - sourceId
11980 amit.gupta 14915 
   - dealerCoupon
11592 amit.gupta 14916 
  """
14917 
 
14918 
  thrift_spec = (
14919 
    None, # 0
14920 
    (1, TType.I64, 'cartId', None, None, ), # 1
14921 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 14922 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 14923 
  )
14924 
 
11980 amit.gupta 14925 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 14926 
    self.cartId = cartId
14927 
    self.sourceId = sourceId
11980 amit.gupta 14928 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 14929 
 
14930 
  def read(self, iprot):
14931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14933 
      return
14934 
    iprot.readStructBegin()
14935 
    while True:
14936 
      (fname, ftype, fid) = iprot.readFieldBegin()
14937 
      if ftype == TType.STOP:
14938 
        break
14939 
      if fid == 1:
14940 
        if ftype == TType.I64:
14941 
          self.cartId = iprot.readI64();
14942 
        else:
14943 
          iprot.skip(ftype)
14944 
      elif fid == 2:
14945 
        if ftype == TType.I64:
14946 
          self.sourceId = iprot.readI64();
14947 
        else:
14948 
          iprot.skip(ftype)
11980 amit.gupta 14949 
      elif fid == 3:
14950 
        if ftype == TType.STRING:
14951 
          self.dealerCoupon = iprot.readString();
14952 
        else:
14953 
          iprot.skip(ftype)
11592 amit.gupta 14954 
      else:
14955 
        iprot.skip(ftype)
14956 
      iprot.readFieldEnd()
14957 
    iprot.readStructEnd()
14958 
 
14959 
  def write(self, oprot):
14960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14962 
      return
14963 
    oprot.writeStructBegin('validateCartPlus_args')
14964 
    if self.cartId is not None:
14965 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14966 
      oprot.writeI64(self.cartId)
14967 
      oprot.writeFieldEnd()
14968 
    if self.sourceId is not None:
14969 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14970 
      oprot.writeI64(self.sourceId)
14971 
      oprot.writeFieldEnd()
11980 amit.gupta 14972 
    if self.dealerCoupon is not None:
14973 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
14974 
      oprot.writeString(self.dealerCoupon)
14975 
      oprot.writeFieldEnd()
11592 amit.gupta 14976 
    oprot.writeFieldStop()
14977 
    oprot.writeStructEnd()
14978 
 
14979 
  def validate(self):
14980 
    return
14981 
 
14982 
 
14983 
  def __repr__(self):
14984 
    L = ['%s=%r' % (key, value)
14985 
      for key, value in self.__dict__.iteritems()]
14986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14987 
 
14988 
  def __eq__(self, other):
14989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14990 
 
14991 
  def __ne__(self, other):
14992 
    return not (self == other)
14993 
 
14994 
class validateCartPlus_result:
14995 
  """
14996 
  Attributes:
14997 
   - success
14998 
   - scex
14999 
  """
15000 
 
15001 
  thrift_spec = (
15002 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15003 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15004 
  )
15005 
 
15006 
  def __init__(self, success=None, scex=None,):
15007 
    self.success = success
15008 
    self.scex = scex
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 0:
15020 
        if ftype == TType.STRUCT:
15021 
          self.success = CartPlus()
15022 
          self.success.read(iprot)
15023 
        else:
15024 
          iprot.skip(ftype)
15025 
      elif fid == 1:
15026 
        if ftype == TType.STRUCT:
15027 
          self.scex = ShoppingCartException()
15028 
          self.scex.read(iprot)
15029 
        else:
15030 
          iprot.skip(ftype)
15031 
      else:
15032 
        iprot.skip(ftype)
15033 
      iprot.readFieldEnd()
15034 
    iprot.readStructEnd()
15035 
 
15036 
  def write(self, oprot):
15037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15039 
      return
15040 
    oprot.writeStructBegin('validateCartPlus_result')
15041 
    if self.success is not None:
15042 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15043 
      self.success.write(oprot)
15044 
      oprot.writeFieldEnd()
15045 
    if self.scex is not None:
15046 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15047 
      self.scex.write(oprot)
15048 
      oprot.writeFieldEnd()
15049 
    oprot.writeFieldStop()
15050 
    oprot.writeStructEnd()
15051 
 
15052 
  def validate(self):
15053 
    return
15054 
 
15055 
 
15056 
  def __repr__(self):
15057 
    L = ['%s=%r' % (key, value)
15058 
      for key, value in self.__dict__.iteritems()]
15059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15060 
 
15061 
  def __eq__(self, other):
15062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15063 
 
15064 
  def __ne__(self, other):
15065 
    return not (self == other)
11679 vikram.rag 15066 
 
15067 
class isPrivateDealUser_args:
15068 
  """
15069 
  Attributes:
15070 
   - userId
15071 
  """
15072 
 
15073 
  thrift_spec = (
15074 
    None, # 0
15075 
    (1, TType.I64, 'userId', None, None, ), # 1
15076 
  )
15077 
 
15078 
  def __init__(self, userId=None,):
15079 
    self.userId = userId
15080 
 
15081 
  def read(self, iprot):
15082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15084 
      return
15085 
    iprot.readStructBegin()
15086 
    while True:
15087 
      (fname, ftype, fid) = iprot.readFieldBegin()
15088 
      if ftype == TType.STOP:
15089 
        break
15090 
      if fid == 1:
15091 
        if ftype == TType.I64:
15092 
          self.userId = iprot.readI64();
15093 
        else:
15094 
          iprot.skip(ftype)
15095 
      else:
15096 
        iprot.skip(ftype)
15097 
      iprot.readFieldEnd()
15098 
    iprot.readStructEnd()
15099 
 
15100 
  def write(self, oprot):
15101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15103 
      return
15104 
    oprot.writeStructBegin('isPrivateDealUser_args')
15105 
    if self.userId is not None:
15106 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15107 
      oprot.writeI64(self.userId)
15108 
      oprot.writeFieldEnd()
15109 
    oprot.writeFieldStop()
15110 
    oprot.writeStructEnd()
15111 
 
15112 
  def validate(self):
15113 
    return
15114 
 
15115 
 
15116 
  def __repr__(self):
15117 
    L = ['%s=%r' % (key, value)
15118 
      for key, value in self.__dict__.iteritems()]
15119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15120 
 
15121 
  def __eq__(self, other):
15122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15123 
 
15124 
  def __ne__(self, other):
15125 
    return not (self == other)
15126 
 
15127 
class isPrivateDealUser_result:
15128 
  """
15129 
  Attributes:
15130 
   - success
15131 
  """
15132 
 
15133 
  thrift_spec = (
15134 
    (0, TType.BOOL, 'success', None, None, ), # 0
15135 
  )
15136 
 
15137 
  def __init__(self, success=None,):
15138 
    self.success = success
15139 
 
15140 
  def read(self, iprot):
15141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15143 
      return
15144 
    iprot.readStructBegin()
15145 
    while True:
15146 
      (fname, ftype, fid) = iprot.readFieldBegin()
15147 
      if ftype == TType.STOP:
15148 
        break
15149 
      if fid == 0:
15150 
        if ftype == TType.BOOL:
15151 
          self.success = iprot.readBool();
15152 
        else:
15153 
          iprot.skip(ftype)
15154 
      else:
15155 
        iprot.skip(ftype)
15156 
      iprot.readFieldEnd()
15157 
    iprot.readStructEnd()
15158 
 
15159 
  def write(self, oprot):
15160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15162 
      return
15163 
    oprot.writeStructBegin('isPrivateDealUser_result')
15164 
    if self.success is not None:
15165 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15166 
      oprot.writeBool(self.success)
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
11890 kshitij.so 15185 
 
15186 
class addPrivateDealUser_args:
15187 
  """
15188 
  Attributes:
15189 
   - userId
15190 
  """
15191 
 
15192 
  thrift_spec = (
15193 
    None, # 0
15194 
    (1, TType.I64, 'userId', None, None, ), # 1
15195 
  )
15196 
 
15197 
  def __init__(self, userId=None,):
15198 
    self.userId = userId
15199 
 
15200 
  def read(self, iprot):
15201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15203 
      return
15204 
    iprot.readStructBegin()
15205 
    while True:
15206 
      (fname, ftype, fid) = iprot.readFieldBegin()
15207 
      if ftype == TType.STOP:
15208 
        break
15209 
      if fid == 1:
15210 
        if ftype == TType.I64:
15211 
          self.userId = iprot.readI64();
15212 
        else:
15213 
          iprot.skip(ftype)
15214 
      else:
15215 
        iprot.skip(ftype)
15216 
      iprot.readFieldEnd()
15217 
    iprot.readStructEnd()
15218 
 
15219 
  def write(self, oprot):
15220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15222 
      return
15223 
    oprot.writeStructBegin('addPrivateDealUser_args')
15224 
    if self.userId is not None:
15225 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15226 
      oprot.writeI64(self.userId)
15227 
      oprot.writeFieldEnd()
15228 
    oprot.writeFieldStop()
15229 
    oprot.writeStructEnd()
15230 
 
15231 
  def validate(self):
15232 
    return
15233 
 
15234 
 
15235 
  def __repr__(self):
15236 
    L = ['%s=%r' % (key, value)
15237 
      for key, value in self.__dict__.iteritems()]
15238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15239 
 
15240 
  def __eq__(self, other):
15241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15242 
 
15243 
  def __ne__(self, other):
15244 
    return not (self == other)
15245 
 
15246 
class addPrivateDealUser_result:
15247 
  """
15248 
  Attributes:
15249 
   - success
15250 
  """
15251 
 
15252 
  thrift_spec = (
15253 
    (0, TType.BOOL, 'success', None, None, ), # 0
15254 
  )
15255 
 
15256 
  def __init__(self, success=None,):
15257 
    self.success = success
15258 
 
15259 
  def read(self, iprot):
15260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15262 
      return
15263 
    iprot.readStructBegin()
15264 
    while True:
15265 
      (fname, ftype, fid) = iprot.readFieldBegin()
15266 
      if ftype == TType.STOP:
15267 
        break
15268 
      if fid == 0:
15269 
        if ftype == TType.BOOL:
15270 
          self.success = iprot.readBool();
15271 
        else:
15272 
          iprot.skip(ftype)
15273 
      else:
15274 
        iprot.skip(ftype)
15275 
      iprot.readFieldEnd()
15276 
    iprot.readStructEnd()
15277 
 
15278 
  def write(self, oprot):
15279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15281 
      return
15282 
    oprot.writeStructBegin('addPrivateDealUser_result')
15283 
    if self.success is not None:
15284 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15285 
      oprot.writeBool(self.success)
15286 
      oprot.writeFieldEnd()
15287 
    oprot.writeFieldStop()
15288 
    oprot.writeStructEnd()
15289 
 
15290 
  def validate(self):
15291 
    return
15292 
 
15293 
 
15294 
  def __repr__(self):
15295 
    L = ['%s=%r' % (key, value)
15296 
      for key, value in self.__dict__.iteritems()]
15297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15298 
 
15299 
  def __eq__(self, other):
15300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15301 
 
15302 
  def __ne__(self, other):
15303 
    return not (self == other)
15304 
 
15305 
class changePrivateDealUserStatus_args:
15306 
  """
15307 
  Attributes:
15308 
   - userId
15309 
   - isActive
15310 
  """
15311 
 
15312 
  thrift_spec = (
15313 
    None, # 0
15314 
    (1, TType.I64, 'userId', None, None, ), # 1
15315 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15316 
  )
15317 
 
15318 
  def __init__(self, userId=None, isActive=None,):
15319 
    self.userId = userId
15320 
    self.isActive = isActive
15321 
 
15322 
  def read(self, iprot):
15323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15325 
      return
15326 
    iprot.readStructBegin()
15327 
    while True:
15328 
      (fname, ftype, fid) = iprot.readFieldBegin()
15329 
      if ftype == TType.STOP:
15330 
        break
15331 
      if fid == 1:
15332 
        if ftype == TType.I64:
15333 
          self.userId = iprot.readI64();
15334 
        else:
15335 
          iprot.skip(ftype)
15336 
      elif fid == 2:
15337 
        if ftype == TType.BOOL:
15338 
          self.isActive = iprot.readBool();
15339 
        else:
15340 
          iprot.skip(ftype)
15341 
      else:
15342 
        iprot.skip(ftype)
15343 
      iprot.readFieldEnd()
15344 
    iprot.readStructEnd()
15345 
 
15346 
  def write(self, oprot):
15347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15349 
      return
15350 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15351 
    if self.userId is not None:
15352 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15353 
      oprot.writeI64(self.userId)
15354 
      oprot.writeFieldEnd()
15355 
    if self.isActive is not None:
15356 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15357 
      oprot.writeBool(self.isActive)
15358 
      oprot.writeFieldEnd()
15359 
    oprot.writeFieldStop()
15360 
    oprot.writeStructEnd()
15361 
 
15362 
  def validate(self):
15363 
    return
15364 
 
15365 
 
15366 
  def __repr__(self):
15367 
    L = ['%s=%r' % (key, value)
15368 
      for key, value in self.__dict__.iteritems()]
15369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15370 
 
15371 
  def __eq__(self, other):
15372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15373 
 
15374 
  def __ne__(self, other):
15375 
    return not (self == other)
15376 
 
15377 
class changePrivateDealUserStatus_result:
15378 
  """
15379 
  Attributes:
15380 
   - success
15381 
  """
15382 
 
15383 
  thrift_spec = (
15384 
    (0, TType.BOOL, 'success', None, None, ), # 0
15385 
  )
15386 
 
15387 
  def __init__(self, success=None,):
15388 
    self.success = success
15389 
 
15390 
  def read(self, iprot):
15391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15393 
      return
15394 
    iprot.readStructBegin()
15395 
    while True:
15396 
      (fname, ftype, fid) = iprot.readFieldBegin()
15397 
      if ftype == TType.STOP:
15398 
        break
15399 
      if fid == 0:
15400 
        if ftype == TType.BOOL:
15401 
          self.success = iprot.readBool();
15402 
        else:
15403 
          iprot.skip(ftype)
15404 
      else:
15405 
        iprot.skip(ftype)
15406 
      iprot.readFieldEnd()
15407 
    iprot.readStructEnd()
15408 
 
15409 
  def write(self, oprot):
15410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15412 
      return
15413 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15414 
    if self.success is not None:
15415 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15416 
      oprot.writeBool(self.success)
15417 
      oprot.writeFieldEnd()
15418 
    oprot.writeFieldStop()
15419 
    oprot.writeStructEnd()
15420 
 
15421 
  def validate(self):
15422 
    return
15423 
 
15424 
 
15425 
  def __repr__(self):
15426 
    L = ['%s=%r' % (key, value)
15427 
      for key, value in self.__dict__.iteritems()]
15428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15429 
 
15430 
  def __eq__(self, other):
15431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15432 
 
15433 
  def __ne__(self, other):
15434 
    return not (self == other)
15435 
 
15436 
class getPrivateDealUser_args:
15437 
  """
15438 
  Attributes:
15439 
   - userId
15440 
  """
15441 
 
15442 
  thrift_spec = (
15443 
    None, # 0
15444 
    (1, TType.I64, 'userId', None, None, ), # 1
15445 
  )
15446 
 
15447 
  def __init__(self, userId=None,):
15448 
    self.userId = userId
15449 
 
15450 
  def read(self, iprot):
15451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15453 
      return
15454 
    iprot.readStructBegin()
15455 
    while True:
15456 
      (fname, ftype, fid) = iprot.readFieldBegin()
15457 
      if ftype == TType.STOP:
15458 
        break
15459 
      if fid == 1:
15460 
        if ftype == TType.I64:
15461 
          self.userId = iprot.readI64();
15462 
        else:
15463 
          iprot.skip(ftype)
15464 
      else:
15465 
        iprot.skip(ftype)
15466 
      iprot.readFieldEnd()
15467 
    iprot.readStructEnd()
15468 
 
15469 
  def write(self, oprot):
15470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15472 
      return
15473 
    oprot.writeStructBegin('getPrivateDealUser_args')
15474 
    if self.userId is not None:
15475 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15476 
      oprot.writeI64(self.userId)
15477 
      oprot.writeFieldEnd()
15478 
    oprot.writeFieldStop()
15479 
    oprot.writeStructEnd()
15480 
 
15481 
  def validate(self):
15482 
    return
15483 
 
15484 
 
15485 
  def __repr__(self):
15486 
    L = ['%s=%r' % (key, value)
15487 
      for key, value in self.__dict__.iteritems()]
15488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15489 
 
15490 
  def __eq__(self, other):
15491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15492 
 
15493 
  def __ne__(self, other):
15494 
    return not (self == other)
15495 
 
15496 
class getPrivateDealUser_result:
15497 
  """
15498 
  Attributes:
15499 
   - success
15500 
  """
15501 
 
15502 
  thrift_spec = (
15503 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15504 
  )
15505 
 
15506 
  def __init__(self, success=None,):
15507 
    self.success = success
15508 
 
15509 
  def read(self, iprot):
15510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15512 
      return
15513 
    iprot.readStructBegin()
15514 
    while True:
15515 
      (fname, ftype, fid) = iprot.readFieldBegin()
15516 
      if ftype == TType.STOP:
15517 
        break
15518 
      if fid == 0:
15519 
        if ftype == TType.STRUCT:
15520 
          self.success = PrivateDealUser()
15521 
          self.success.read(iprot)
15522 
        else:
15523 
          iprot.skip(ftype)
15524 
      else:
15525 
        iprot.skip(ftype)
15526 
      iprot.readFieldEnd()
15527 
    iprot.readStructEnd()
15528 
 
15529 
  def write(self, oprot):
15530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15532 
      return
15533 
    oprot.writeStructBegin('getPrivateDealUser_result')
15534 
    if self.success is not None:
15535 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15536 
      self.success.write(oprot)
15537 
      oprot.writeFieldEnd()
15538 
    oprot.writeFieldStop()
15539 
    oprot.writeStructEnd()
15540 
 
15541 
  def validate(self):
15542 
    return
15543 
 
15544 
 
15545 
  def __repr__(self):
15546 
    L = ['%s=%r' % (key, value)
15547 
      for key, value in self.__dict__.iteritems()]
15548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15549 
 
15550 
  def __eq__(self, other):
15551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15552 
 
15553 
  def __ne__(self, other):
15554 
    return not (self == other)
12696 amit.gupta 15555 
 
15556 
class registerCounter_args:
15557 
  """
15558 
  Attributes:
15559 
   - counter
15560 
   - userId
15561 
  """
15562 
 
15563 
  thrift_spec = (
15564 
    None, # 0
15565 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15566 
    (2, TType.I64, 'userId', None, None, ), # 2
15567 
  )
15568 
 
15569 
  def __init__(self, counter=None, userId=None,):
15570 
    self.counter = counter
15571 
    self.userId = userId
15572 
 
15573 
  def read(self, iprot):
15574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15576 
      return
15577 
    iprot.readStructBegin()
15578 
    while True:
15579 
      (fname, ftype, fid) = iprot.readFieldBegin()
15580 
      if ftype == TType.STOP:
15581 
        break
15582 
      if fid == 1:
15583 
        if ftype == TType.STRUCT:
15584 
          self.counter = Counter()
15585 
          self.counter.read(iprot)
15586 
        else:
15587 
          iprot.skip(ftype)
15588 
      elif fid == 2:
15589 
        if ftype == TType.I64:
15590 
          self.userId = iprot.readI64();
15591 
        else:
15592 
          iprot.skip(ftype)
15593 
      else:
15594 
        iprot.skip(ftype)
15595 
      iprot.readFieldEnd()
15596 
    iprot.readStructEnd()
15597 
 
15598 
  def write(self, oprot):
15599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15601 
      return
15602 
    oprot.writeStructBegin('registerCounter_args')
15603 
    if self.counter is not None:
15604 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15605 
      self.counter.write(oprot)
15606 
      oprot.writeFieldEnd()
15607 
    if self.userId is not None:
15608 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15609 
      oprot.writeI64(self.userId)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
15629 
class registerCounter_result:
15630 
  """
15631 
  Attributes:
15632 
   - success
15633 
  """
15634 
 
15635 
  thrift_spec = (
15636 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15637 
  )
15638 
 
15639 
  def __init__(self, success=None,):
15640 
    self.success = success
15641 
 
15642 
  def read(self, iprot):
15643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15645 
      return
15646 
    iprot.readStructBegin()
15647 
    while True:
15648 
      (fname, ftype, fid) = iprot.readFieldBegin()
15649 
      if ftype == TType.STOP:
15650 
        break
15651 
      if fid == 0:
15652 
        if ftype == TType.MAP:
15653 
          self.success = {}
15654 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15655 
          for _i229 in xrange(_size225):
15656 
            _key230 = iprot.readString();
15657 
            _val231 = iprot.readString();
15658 
            self.success[_key230] = _val231
15659 
          iprot.readMapEnd()
15660 
        else:
15661 
          iprot.skip(ftype)
15662 
      else:
15663 
        iprot.skip(ftype)
15664 
      iprot.readFieldEnd()
15665 
    iprot.readStructEnd()
15666 
 
15667 
  def write(self, oprot):
15668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15670 
      return
15671 
    oprot.writeStructBegin('registerCounter_result')
15672 
    if self.success is not None:
15673 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15674 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15675 
      for kiter232,viter233 in self.success.items():
15676 
        oprot.writeString(kiter232)
15677 
        oprot.writeString(viter233)
15678 
      oprot.writeMapEnd()
15679 
      oprot.writeFieldEnd()
15680 
    oprot.writeFieldStop()
15681 
    oprot.writeStructEnd()
15682 
 
15683 
  def validate(self):
15684 
    return
15685 
 
15686 
 
15687 
  def __repr__(self):
15688 
    L = ['%s=%r' % (key, value)
15689 
      for key, value in self.__dict__.iteritems()]
15690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15691 
 
15692 
  def __eq__(self, other):
15693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15694 
 
15695 
  def __ne__(self, other):
15696 
    return not (self == other)
12722 amit.gupta 15697 
 
15698 
class searchCounter_args:
15699 
  """
15700 
  Attributes:
15701 
   - type1
15702 
   - searchString
15703 
  """
15704 
 
15705 
  thrift_spec = (
15706 
    None, # 0
15707 
    (1, TType.STRING, 'type1', None, None, ), # 1
15708 
    (2, TType.STRING, 'searchString', None, None, ), # 2
15709 
  )
15710 
 
15711 
  def __init__(self, type1=None, searchString=None,):
15712 
    self.type1 = type1
15713 
    self.searchString = searchString
15714 
 
15715 
  def read(self, iprot):
15716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15718 
      return
15719 
    iprot.readStructBegin()
15720 
    while True:
15721 
      (fname, ftype, fid) = iprot.readFieldBegin()
15722 
      if ftype == TType.STOP:
15723 
        break
15724 
      if fid == 1:
15725 
        if ftype == TType.STRING:
15726 
          self.type1 = iprot.readString();
15727 
        else:
15728 
          iprot.skip(ftype)
15729 
      elif fid == 2:
15730 
        if ftype == TType.STRING:
15731 
          self.searchString = iprot.readString();
15732 
        else:
15733 
          iprot.skip(ftype)
15734 
      else:
15735 
        iprot.skip(ftype)
15736 
      iprot.readFieldEnd()
15737 
    iprot.readStructEnd()
15738 
 
15739 
  def write(self, oprot):
15740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15742 
      return
15743 
    oprot.writeStructBegin('searchCounter_args')
15744 
    if self.type1 is not None:
15745 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
15746 
      oprot.writeString(self.type1)
15747 
      oprot.writeFieldEnd()
15748 
    if self.searchString is not None:
15749 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
15750 
      oprot.writeString(self.searchString)
15751 
      oprot.writeFieldEnd()
15752 
    oprot.writeFieldStop()
15753 
    oprot.writeStructEnd()
15754 
 
15755 
  def validate(self):
15756 
    return
15757 
 
15758 
 
15759 
  def __repr__(self):
15760 
    L = ['%s=%r' % (key, value)
15761 
      for key, value in self.__dict__.iteritems()]
15762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15763 
 
15764 
  def __eq__(self, other):
15765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15766 
 
15767 
  def __ne__(self, other):
15768 
    return not (self == other)
15769 
 
15770 
class searchCounter_result:
15771 
  """
15772 
  Attributes:
15773 
   - success
15774 
  """
15775 
 
15776 
  thrift_spec = (
15777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
15778 
  )
15779 
 
15780 
  def __init__(self, success=None,):
15781 
    self.success = success
15782 
 
15783 
  def read(self, iprot):
15784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15786 
      return
15787 
    iprot.readStructBegin()
15788 
    while True:
15789 
      (fname, ftype, fid) = iprot.readFieldBegin()
15790 
      if ftype == TType.STOP:
15791 
        break
15792 
      if fid == 0:
15793 
        if ftype == TType.LIST:
15794 
          self.success = []
15795 
          (_etype237, _size234) = iprot.readListBegin()
15796 
          for _i238 in xrange(_size234):
15797 
            _elem239 = Counter()
15798 
            _elem239.read(iprot)
15799 
            self.success.append(_elem239)
15800 
          iprot.readListEnd()
15801 
        else:
15802 
          iprot.skip(ftype)
15803 
      else:
15804 
        iprot.skip(ftype)
15805 
      iprot.readFieldEnd()
15806 
    iprot.readStructEnd()
15807 
 
15808 
  def write(self, oprot):
15809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15811 
      return
15812 
    oprot.writeStructBegin('searchCounter_result')
15813 
    if self.success is not None:
15814 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15815 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15816 
      for iter240 in self.success:
15817 
        iter240.write(oprot)
15818 
      oprot.writeListEnd()
15819 
      oprot.writeFieldEnd()
15820 
    oprot.writeFieldStop()
15821 
    oprot.writeStructEnd()
15822 
 
15823 
  def validate(self):
15824 
    return
15825 
 
15826 
 
15827 
  def __repr__(self):
15828 
    L = ['%s=%r' % (key, value)
15829 
      for key, value in self.__dict__.iteritems()]
15830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15831 
 
15832 
  def __eq__(self, other):
15833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15834 
 
15835 
  def __ne__(self, other):
15836 
    return not (self == other)
15837 
 
15838 
class getAllUsersByCounter_args:
15839 
  """
15840 
  Attributes:
15841 
   - counterId
15842 
  """
15843 
 
15844 
  thrift_spec = (
15845 
    None, # 0
15846 
    (1, TType.I64, 'counterId', None, None, ), # 1
15847 
  )
15848 
 
15849 
  def __init__(self, counterId=None,):
15850 
    self.counterId = counterId
15851 
 
15852 
  def read(self, iprot):
15853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15855 
      return
15856 
    iprot.readStructBegin()
15857 
    while True:
15858 
      (fname, ftype, fid) = iprot.readFieldBegin()
15859 
      if ftype == TType.STOP:
15860 
        break
15861 
      if fid == 1:
15862 
        if ftype == TType.I64:
15863 
          self.counterId = iprot.readI64();
15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      else:
15867 
        iprot.skip(ftype)
15868 
      iprot.readFieldEnd()
15869 
    iprot.readStructEnd()
15870 
 
15871 
  def write(self, oprot):
15872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15874 
      return
15875 
    oprot.writeStructBegin('getAllUsersByCounter_args')
15876 
    if self.counterId is not None:
15877 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
15878 
      oprot.writeI64(self.counterId)
15879 
      oprot.writeFieldEnd()
15880 
    oprot.writeFieldStop()
15881 
    oprot.writeStructEnd()
15882 
 
15883 
  def validate(self):
15884 
    return
15885 
 
15886 
 
15887 
  def __repr__(self):
15888 
    L = ['%s=%r' % (key, value)
15889 
      for key, value in self.__dict__.iteritems()]
15890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15891 
 
15892 
  def __eq__(self, other):
15893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15894 
 
15895 
  def __ne__(self, other):
15896 
    return not (self == other)
15897 
 
15898 
class getAllUsersByCounter_result:
15899 
  """
15900 
  Attributes:
15901 
   - success
15902 
  """
15903 
 
15904 
  thrift_spec = (
15905 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
15906 
  )
15907 
 
15908 
  def __init__(self, success=None,):
15909 
    self.success = success
15910 
 
15911 
  def read(self, iprot):
15912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15914 
      return
15915 
    iprot.readStructBegin()
15916 
    while True:
15917 
      (fname, ftype, fid) = iprot.readFieldBegin()
15918 
      if ftype == TType.STOP:
15919 
        break
15920 
      if fid == 0:
15921 
        if ftype == TType.LIST:
15922 
          self.success = []
15923 
          (_etype244, _size241) = iprot.readListBegin()
15924 
          for _i245 in xrange(_size241):
15925 
            _elem246 = User()
15926 
            _elem246.read(iprot)
15927 
            self.success.append(_elem246)
15928 
          iprot.readListEnd()
15929 
        else:
15930 
          iprot.skip(ftype)
15931 
      else:
15932 
        iprot.skip(ftype)
15933 
      iprot.readFieldEnd()
15934 
    iprot.readStructEnd()
15935 
 
15936 
  def write(self, oprot):
15937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15939 
      return
15940 
    oprot.writeStructBegin('getAllUsersByCounter_result')
15941 
    if self.success is not None:
15942 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15943 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15944 
      for iter247 in self.success:
15945 
        iter247.write(oprot)
15946 
      oprot.writeListEnd()
15947 
      oprot.writeFieldEnd()
15948 
    oprot.writeFieldStop()
15949 
    oprot.writeStructEnd()
15950 
 
15951 
  def validate(self):
15952 
    return
15953 
 
15954 
 
15955 
  def __repr__(self):
15956 
    L = ['%s=%r' % (key, value)
15957 
      for key, value in self.__dict__.iteritems()]
15958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15959 
 
15960 
  def __eq__(self, other):
15961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15962 
 
15963 
  def __ne__(self, other):
15964 
    return not (self == other)
15251 manish.sha 15965 
 
15966 
class getActiveAccessTokenForUser_args:
15967 
  """
15968 
  Attributes:
15969 
   - userId
15970 
   - source
15971 
  """
15972 
 
15973 
  thrift_spec = (
15974 
    None, # 0
15975 
    (1, TType.I64, 'userId', None, None, ), # 1
15976 
    (2, TType.STRING, 'source', None, None, ), # 2
15977 
  )
15978 
 
15979 
  def __init__(self, userId=None, source=None,):
15980 
    self.userId = userId
15981 
    self.source = source
15982 
 
15983 
  def read(self, iprot):
15984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15986 
      return
15987 
    iprot.readStructBegin()
15988 
    while True:
15989 
      (fname, ftype, fid) = iprot.readFieldBegin()
15990 
      if ftype == TType.STOP:
15991 
        break
15992 
      if fid == 1:
15993 
        if ftype == TType.I64:
15994 
          self.userId = iprot.readI64();
15995 
        else:
15996 
          iprot.skip(ftype)
15997 
      elif fid == 2:
15998 
        if ftype == TType.STRING:
15999 
          self.source = iprot.readString();
16000 
        else:
16001 
          iprot.skip(ftype)
16002 
      else:
16003 
        iprot.skip(ftype)
16004 
      iprot.readFieldEnd()
16005 
    iprot.readStructEnd()
16006 
 
16007 
  def write(self, oprot):
16008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16010 
      return
16011 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16012 
    if self.userId is not None:
16013 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16014 
      oprot.writeI64(self.userId)
16015 
      oprot.writeFieldEnd()
16016 
    if self.source is not None:
16017 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16018 
      oprot.writeString(self.source)
16019 
      oprot.writeFieldEnd()
16020 
    oprot.writeFieldStop()
16021 
    oprot.writeStructEnd()
16022 
 
16023 
  def validate(self):
16024 
    return
16025 
 
16026 
 
16027 
  def __repr__(self):
16028 
    L = ['%s=%r' % (key, value)
16029 
      for key, value in self.__dict__.iteritems()]
16030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16031 
 
16032 
  def __eq__(self, other):
16033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16034 
 
16035 
  def __ne__(self, other):
16036 
    return not (self == other)
16037 
 
16038 
class getActiveAccessTokenForUser_result:
16039 
  """
16040 
  Attributes:
16041 
   - success
16042 
  """
16043 
 
16044 
  thrift_spec = (
16045 
    (0, TType.STRING, 'success', None, None, ), # 0
16046 
  )
16047 
 
16048 
  def __init__(self, success=None,):
16049 
    self.success = success
16050 
 
16051 
  def read(self, iprot):
16052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16054 
      return
16055 
    iprot.readStructBegin()
16056 
    while True:
16057 
      (fname, ftype, fid) = iprot.readFieldBegin()
16058 
      if ftype == TType.STOP:
16059 
        break
16060 
      if fid == 0:
16061 
        if ftype == TType.STRING:
16062 
          self.success = iprot.readString();
16063 
        else:
16064 
          iprot.skip(ftype)
16065 
      else:
16066 
        iprot.skip(ftype)
16067 
      iprot.readFieldEnd()
16068 
    iprot.readStructEnd()
16069 
 
16070 
  def write(self, oprot):
16071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16073 
      return
16074 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16075 
    if self.success is not None:
16076 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16077 
      oprot.writeString(self.success)
16078 
      oprot.writeFieldEnd()
16079 
    oprot.writeFieldStop()
16080 
    oprot.writeStructEnd()
16081 
 
16082 
  def validate(self):
16083 
    return
16084 
 
16085 
 
16086 
  def __repr__(self):
16087 
    L = ['%s=%r' % (key, value)
16088 
      for key, value in self.__dict__.iteritems()]
16089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16090 
 
16091 
  def __eq__(self, other):
16092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16093 
 
16094 
  def __ne__(self, other):
16095 
    return not (self == other)
16096 
 
16097 
class validateAccessToken_args:
16098 
  """
16099 
  Attributes:
16100 
   - accessToken
16101 
  """
16102 
 
16103 
  thrift_spec = (
16104 
    None, # 0
16105 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16106 
  )
16107 
 
16108 
  def __init__(self, accessToken=None,):
16109 
    self.accessToken = accessToken
16110 
 
16111 
  def read(self, iprot):
16112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16114 
      return
16115 
    iprot.readStructBegin()
16116 
    while True:
16117 
      (fname, ftype, fid) = iprot.readFieldBegin()
16118 
      if ftype == TType.STOP:
16119 
        break
16120 
      if fid == 1:
16121 
        if ftype == TType.STRING:
16122 
          self.accessToken = iprot.readString();
16123 
        else:
16124 
          iprot.skip(ftype)
16125 
      else:
16126 
        iprot.skip(ftype)
16127 
      iprot.readFieldEnd()
16128 
    iprot.readStructEnd()
16129 
 
16130 
  def write(self, oprot):
16131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16133 
      return
16134 
    oprot.writeStructBegin('validateAccessToken_args')
16135 
    if self.accessToken is not None:
16136 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16137 
      oprot.writeString(self.accessToken)
16138 
      oprot.writeFieldEnd()
16139 
    oprot.writeFieldStop()
16140 
    oprot.writeStructEnd()
16141 
 
16142 
  def validate(self):
16143 
    return
16144 
 
16145 
 
16146 
  def __repr__(self):
16147 
    L = ['%s=%r' % (key, value)
16148 
      for key, value in self.__dict__.iteritems()]
16149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16150 
 
16151 
  def __eq__(self, other):
16152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16153 
 
16154 
  def __ne__(self, other):
16155 
    return not (self == other)
16156 
 
16157 
class validateAccessToken_result:
16158 
  """
16159 
  Attributes:
16160 
   - success
16161 
  """
16162 
 
16163 
  thrift_spec = (
16164 
    (0, TType.BOOL, 'success', None, None, ), # 0
16165 
  )
16166 
 
16167 
  def __init__(self, success=None,):
16168 
    self.success = success
16169 
 
16170 
  def read(self, iprot):
16171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16173 
      return
16174 
    iprot.readStructBegin()
16175 
    while True:
16176 
      (fname, ftype, fid) = iprot.readFieldBegin()
16177 
      if ftype == TType.STOP:
16178 
        break
16179 
      if fid == 0:
16180 
        if ftype == TType.BOOL:
16181 
          self.success = iprot.readBool();
16182 
        else:
16183 
          iprot.skip(ftype)
16184 
      else:
16185 
        iprot.skip(ftype)
16186 
      iprot.readFieldEnd()
16187 
    iprot.readStructEnd()
16188 
 
16189 
  def write(self, oprot):
16190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16192 
      return
16193 
    oprot.writeStructBegin('validateAccessToken_result')
16194 
    if self.success is not None:
16195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16196 
      oprot.writeBool(self.success)
16197 
      oprot.writeFieldEnd()
16198 
    oprot.writeFieldStop()
16199 
    oprot.writeStructEnd()
16200 
 
16201 
  def validate(self):
16202 
    return
16203 
 
16204 
 
16205 
  def __repr__(self):
16206 
    L = ['%s=%r' % (key, value)
16207 
      for key, value in self.__dict__.iteritems()]
16208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16209 
 
16210 
  def __eq__(self, other):
16211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16212 
 
16213 
  def __ne__(self, other):
16214 
    return not (self == other)