Subversion Repositories SmartDukaan

Rev

Rev 20873 | Rev 22358 | 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 
 
21454 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
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
21454 amit.gupta 421 
     - selfPickup
559 chandransh 422 
    """
423 
    pass
424 
 
3557 rajveer 425 
  def validateCart(self, cartId, sourceId):
559 chandransh 426 
    """
690 chandransh 427 
    Validates that:
428 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 429 
    2. All of the lines in the cart are active items.
690 chandransh 430 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 431 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 432 
 
559 chandransh 433 
    Parameters:
434 
     - cartId
3557 rajveer 435 
     - sourceId
559 chandransh 436 
    """
437 
    pass
438 
 
11980 amit.gupta 439 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
440 
    """
441 
    Validates that:
442 
    1. The checkout timestamp is greater than the updatedOn timestamp.
443 
    2. All of the lines in the cart are active items.
444 
    3. The estimate for any of the lines in cart doesn't change.
445 
    If all three are true, returns empty string; else returns appropriate message.
446 
 
447 
    Parameters:
448 
     - cartId
449 
     - sourceId
450 
     - dealCoupon
451 
    """
452 
    pass
453 
 
690 chandransh 454 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 455 
    """
690 chandransh 456 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 457 
 
575 chandransh 458 
    Parameters:
690 chandransh 459 
     - fromCartId
460 
     - toCartId
461 
    """
462 
    pass
463 
 
464 
  def checkOut(self, cartId):
465 
    """
466 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 467 
 
690 chandransh 468 
    Parameters:
575 chandransh 469 
     - cartId
470 
    """
471 
    pass
472 
 
690 chandransh 473 
  def resetCart(self, cartId, items):
559 chandransh 474 
    """
690 chandransh 475 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
476 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 477 
 
559 chandransh 478 
    Parameters:
690 chandransh 479 
     - cartId
480 
     - items
559 chandransh 481 
    """
482 
    pass
483 
 
2981 rajveer 484 
  def getUserCount(self, userType):
559 chandransh 485 
    """
2981 rajveer 486 
    Returns number of registered users.
487 
    If userType = null, then it returns count of all users, including anonymous
488 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
489 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 490 
 
559 chandransh 491 
    Parameters:
2981 rajveer 492 
     - userType
559 chandransh 493 
    """
494 
    pass
495 
 
2981 rajveer 496 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 497 
    """
2981 rajveer 498 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
499 
    If any of startDate or endDate is -1, then that filter is ignored.
500 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 501 
 
502 
 
559 chandransh 503 
    Parameters:
2981 rajveer 504 
     - userType
505 
     - startDate
506 
     - endDate
559 chandransh 507 
    """
508 
    pass
509 
 
2981 rajveer 510 
  def getMyResearchItems(self, userId):
559 chandransh 511 
    """
2981 rajveer 512 
    Returns list of item ids in myresearch for the user
3431 rajveer 513 
 
559 chandransh 514 
    Parameters:
515 
     - userId
516 
    """
517 
    pass
518 
 
2981 rajveer 519 
  def updateMyResearch(self, userId, itemId):
559 chandransh 520 
    """
2981 rajveer 521 
    add item to my research for a user
3431 rajveer 522 
 
559 chandransh 523 
    Parameters:
2981 rajveer 524 
     - userId
525 
     - itemId
559 chandransh 526 
    """
527 
    pass
528 
 
2981 rajveer 529 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 530 
    """
2981 rajveer 531 
    delete item from my research for a user
3431 rajveer 532 
 
1596 ankur.sing 533 
    Parameters:
2981 rajveer 534 
     - userId
535 
     - itemId
1596 ankur.sing 536 
    """
537 
    pass
559 chandransh 538 
 
2981 rajveer 539 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 540 
    """
2981 rajveer 541 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 542 
 
1673 ankur.sing 543 
    Parameters:
2981 rajveer 544 
     - userId
1673 ankur.sing 545 
    """
546 
    pass
1596 ankur.sing 547 
 
2981 rajveer 548 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 549 
    """
2981 rajveer 550 
    add item to browse history for a user
3431 rajveer 551 
 
2642 varun.gupt 552 
    Parameters:
2981 rajveer 553 
     - userId
554 
     - itemId
2642 varun.gupt 555 
    """
556 
    pass
1673 ankur.sing 557 
 
3385 varun.gupt 558 
  def getCartsWithCouponCount(self, couponCode):
559 
    """
560 
    Returns count of Carts with given coupon applied
3431 rajveer 561 
 
3385 varun.gupt 562 
    Parameters:
563 
     - couponCode
564 
    """
565 
    pass
2642 varun.gupt 566 
 
3499 mandeep.dh 567 
  def increaseTrustLevel(self, userId, trustLevelDelta):
568 
    """
569 
    Updates COD trust level of a user
3385 varun.gupt 570 
 
3499 mandeep.dh 571 
    Parameters:
572 
     - userId
573 
     - trustLevelDelta
574 
    """
575 
    pass
576 
 
5407 amar.kumar 577 
  def getTrustLevel(self, userId):
578 
    """
579 
    Get trust level of a user
580 
 
581 
    Parameters:
582 
     - userId
583 
    """
584 
    pass
585 
 
4668 varun.gupt 586 
  def showCODOption(self, cartId, sourceId, pincode):
587 
    """
588 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 589 
 
4668 varun.gupt 590 
    Parameters:
591 
     - cartId
592 
     - sourceId
593 
     - pincode
594 
    """
595 
    pass
596 
 
5623 anupam.sin 597 
  def getUserEmails(self, startDate, endDate):
598 
    """
599 
    Get email addresses for users activated within a given date range
4668 varun.gupt 600 
 
5623 anupam.sin 601 
    Parameters:
602 
     - startDate
603 
     - endDate
604 
    """
605 
    pass
606 
 
9299 kshitij.so 607 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 608 
    """
609 
    Mark a cart lineitem as insured. Returns true/false.
610 
 
611 
    Parameters:
612 
     - itemId
613 
     - cartId
614 
     - toInsure
9299 kshitij.so 615 
     - insurerType
6903 anupam.sin 616 
    """
617 
    pass
618 
 
619 
  def cancelInsurance(self, cartId):
620 
    """
621 
    Cancel insurance for all items in the cart
622 
 
623 
    Parameters:
624 
     - cartId
625 
    """
626 
    pass
627 
 
628 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
629 
    """
630 
    Stores insurance specific details like date of birth and guardianName
631 
 
632 
    Parameters:
633 
     - addressId
634 
     - dob
635 
     - guardianName
636 
    """
637 
    pass
638 
 
639 
  def isInsuranceDetailPresent(self, addressId):
640 
    """
641 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
642 
 
643 
    Parameters:
644 
     - addressId
645 
    """
646 
    pass
647 
 
9791 rajveer 648 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 649 
    """
9791 rajveer 650 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 651 
 
6821 amar.kumar 652 
    Parameters:
653 
     - startDate
654 
     - endDate
655 
    """
656 
    pass
657 
 
11980 amit.gupta 658 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 659 
    """
660 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 661 
 
11592 amit.gupta 662 
    Parameters:
663 
     - cartId
664 
     - sourceId
11980 amit.gupta 665 
     - dealerCoupon
11592 amit.gupta 666 
    """
667 
    pass
668 
 
11679 vikram.rag 669 
  def isPrivateDealUser(self, userId):
670 
    """
671 
    Parameters:
672 
     - userId
673 
    """
674 
    pass
11592 amit.gupta 675 
 
11890 kshitij.so 676 
  def addPrivateDealUser(self, userId):
677 
    """
678 
    Parameters:
679 
     - userId
680 
    """
681 
    pass
11679 vikram.rag 682 
 
11890 kshitij.so 683 
  def changePrivateDealUserStatus(self, userId, isActive):
684 
    """
685 
    Parameters:
686 
     - userId
687 
     - isActive
688 
    """
689 
    pass
690 
 
691 
  def getPrivateDealUser(self, userId):
692 
    """
693 
    Parameters:
694 
     - userId
695 
    """
696 
    pass
697 
 
12696 amit.gupta 698 
  def registerCounter(self, counter, userId):
699 
    """
700 
    Parameters:
701 
     - counter
702 
     - userId
703 
    """
704 
    pass
11890 kshitij.so 705 
 
12722 amit.gupta 706 
  def searchCounter(self, type1, searchString):
707 
    """
708 
    Parameters:
709 
     - type1
710 
     - searchString
711 
    """
712 
    pass
12696 amit.gupta 713 
 
18977 amit.gupta 714 
  def getCounterByUserId(self, userId):
715 
    """
716 
    Parameters:
717 
     - userId
718 
    """
719 
    pass
720 
 
12722 amit.gupta 721 
  def getAllUsersByCounter(self, counterId):
722 
    """
723 
    Parameters:
724 
     - counterId
725 
    """
726 
    pass
727 
 
15251 manish.sha 728 
  def getActiveAccessTokenForUser(self, userId, source):
729 
    """
730 
    Parameters:
731 
     - userId
732 
     - source
733 
    """
734 
    pass
12722 amit.gupta 735 
 
15251 manish.sha 736 
  def validateAccessToken(self, accessToken):
737 
    """
738 
    Parameters:
739 
     - accessToken
740 
    """
741 
    pass
742 
 
17782 amit.gupta 743 
  def addItemsToCart(self, cartId, itemQty, couponCode):
744 
    """
745 
    Parameters:
746 
     - cartId
747 
     - itemQty
748 
     - couponCode
749 
    """
750 
    pass
15251 manish.sha 751 
 
17782 amit.gupta 752 
  def validateCartNew(self, cartId, pinCode, sourceId):
753 
    """
754 
    Parameters:
755 
     - cartId
756 
     - pinCode
757 
     - sourceId
758 
    """
759 
    pass
760 
 
18644 manish.sha 761 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 762 
    """
763 
    Parameters:
764 
     - userId
765 
    """
766 
    pass
17782 amit.gupta 767 
 
18530 manish.sha 768 
  def getBillingAddressForUser(self, userId):
769 
    """
770 
    Parameters:
771 
     - userId
772 
    """
773 
    pass
774 
 
18590 manish.sha 775 
  def isCreditorAssigned(self, userId):
776 
    """
777 
    Parameters:
778 
     - userId
779 
    """
780 
    pass
18530 manish.sha 781 
 
18735 manish.sha 782 
  def isTaxInvoiceEnabledUser(self, userId):
783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
787 
    pass
18590 manish.sha 788 
 
19182 amit.gupta 789 
  def taxInvoiceAvailable(self, addressId):
790 
    """
791 
    Parameters:
792 
     - addressId
793 
    """
794 
    pass
795 
 
18764 kshitij.so 796 
  def getCartByValue(self, cartIds):
797 
    """
798 
    Parameters:
799 
     - cartIds
800 
    """
801 
    pass
18735 manish.sha 802 
 
19889 manas 803 
  def getCounterName(self, userIds):
804 
    """
805 
    Parameters:
806 
     - userIds
807 
    """
808 
    pass
18764 kshitij.so 809 
 
20873 kshitij.so 810 
  def setWalletAmountInCart(self, cartId, wallet_amount):
811 
    """
812 
    Parameters:
813 
     - cartId
814 
     - wallet_amount
815 
    """
816 
    pass
19889 manas 817 
 
20873 kshitij.so 818 
 
3376 rajveer 819 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 820 
  """
821 
  service
822 
  """
823 
  def __init__(self, iprot, oprot=None):
3376 rajveer 824 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 825 
 
559 chandransh 826 
  def createAnonymousUser(self, jsessionId):
94 ashish 827 
    """
828 
    Parameters:
559 chandransh 829 
     - jsessionId
94 ashish 830 
    """
559 chandransh 831 
    self.send_createAnonymousUser(jsessionId)
832 
    return self.recv_createAnonymousUser()
94 ashish 833 
 
559 chandransh 834 
  def send_createAnonymousUser(self, jsessionId):
835 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
836 
    args = createAnonymousUser_args()
837 
    args.jsessionId = jsessionId
94 ashish 838 
    args.write(self._oprot)
839 
    self._oprot.writeMessageEnd()
840 
    self._oprot.trans.flush()
841 
 
559 chandransh 842 
  def recv_createAnonymousUser(self, ):
94 ashish 843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
844 
    if mtype == TMessageType.EXCEPTION:
845 
      x = TApplicationException()
846 
      x.read(self._iprot)
847 
      self._iprot.readMessageEnd()
848 
      raise x
559 chandransh 849 
    result = createAnonymousUser_result()
94 ashish 850 
    result.read(self._iprot)
851 
    self._iprot.readMessageEnd()
3431 rajveer 852 
    if result.success is not None:
94 ashish 853 
      return result.success
3431 rajveer 854 
    if result.ucex is not None:
559 chandransh 855 
      raise result.ucex
856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 857 
 
559 chandransh 858 
  def getUserById(self, userId):
94 ashish 859 
    """
860 
    Parameters:
861 
     - userId
862 
    """
559 chandransh 863 
    self.send_getUserById(userId)
864 
    return self.recv_getUserById()
94 ashish 865 
 
559 chandransh 866 
  def send_getUserById(self, userId):
867 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
868 
    args = getUserById_args()
94 ashish 869 
    args.userId = userId
870 
    args.write(self._oprot)
871 
    self._oprot.writeMessageEnd()
872 
    self._oprot.trans.flush()
873 
 
559 chandransh 874 
  def recv_getUserById(self, ):
94 ashish 875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
876 
    if mtype == TMessageType.EXCEPTION:
877 
      x = TApplicationException()
878 
      x.read(self._iprot)
879 
      self._iprot.readMessageEnd()
880 
      raise x
559 chandransh 881 
    result = getUserById_result()
94 ashish 882 
    result.read(self._iprot)
883 
    self._iprot.readMessageEnd()
3431 rajveer 884 
    if result.success is not None:
94 ashish 885 
      return result.success
3431 rajveer 886 
    if result.ucex is not None:
559 chandransh 887 
      raise result.ucex
888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 889 
 
5326 rajveer 890 
  def getUserByCartId(self, cartId):
891 
    """
892 
    Parameters:
893 
     - cartId
894 
    """
895 
    self.send_getUserByCartId(cartId)
896 
    return self.recv_getUserByCartId()
897 
 
898 
  def send_getUserByCartId(self, cartId):
899 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
900 
    args = getUserByCartId_args()
901 
    args.cartId = cartId
902 
    args.write(self._oprot)
903 
    self._oprot.writeMessageEnd()
904 
    self._oprot.trans.flush()
905 
 
906 
  def recv_getUserByCartId(self, ):
907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
908 
    if mtype == TMessageType.EXCEPTION:
909 
      x = TApplicationException()
910 
      x.read(self._iprot)
911 
      self._iprot.readMessageEnd()
912 
      raise x
913 
    result = getUserByCartId_result()
914 
    result.read(self._iprot)
915 
    self._iprot.readMessageEnd()
916 
    if result.success is not None:
917 
      return result.success
918 
    if result.ucex is not None:
919 
      raise result.ucex
920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
921 
 
1491 vikas 922 
  def getUserByEmail(self, email):
923 
    """
924 
    Parameters:
925 
     - email
926 
    """
927 
    self.send_getUserByEmail(email)
928 
    return self.recv_getUserByEmail()
929 
 
930 
  def send_getUserByEmail(self, email):
931 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
932 
    args = getUserByEmail_args()
933 
    args.email = email
934 
    args.write(self._oprot)
935 
    self._oprot.writeMessageEnd()
936 
    self._oprot.trans.flush()
937 
 
938 
  def recv_getUserByEmail(self, ):
939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
940 
    if mtype == TMessageType.EXCEPTION:
941 
      x = TApplicationException()
942 
      x.read(self._iprot)
943 
      self._iprot.readMessageEnd()
944 
      raise x
945 
    result = getUserByEmail_result()
946 
    result.read(self._iprot)
947 
    self._iprot.readMessageEnd()
3431 rajveer 948 
    if result.success is not None:
1491 vikas 949 
      return result.success
3431 rajveer 950 
    if result.ucex is not None:
1491 vikas 951 
      raise result.ucex
952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
953 
 
3032 mandeep.dh 954 
  def getUserByMobileNumber(self, mobileNumber):
955 
    """
956 
    Parameters:
957 
     - mobileNumber
958 
    """
959 
    self.send_getUserByMobileNumber(mobileNumber)
960 
    return self.recv_getUserByMobileNumber()
961 
 
962 
  def send_getUserByMobileNumber(self, mobileNumber):
963 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
964 
    args = getUserByMobileNumber_args()
965 
    args.mobileNumber = mobileNumber
966 
    args.write(self._oprot)
967 
    self._oprot.writeMessageEnd()
968 
    self._oprot.trans.flush()
969 
 
970 
  def recv_getUserByMobileNumber(self, ):
971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
972 
    if mtype == TMessageType.EXCEPTION:
973 
      x = TApplicationException()
974 
      x.read(self._iprot)
975 
      self._iprot.readMessageEnd()
976 
      raise x
977 
    result = getUserByMobileNumber_result()
978 
    result.read(self._iprot)
979 
    self._iprot.readMessageEnd()
3431 rajveer 980 
    if result.success is not None:
3032 mandeep.dh 981 
      return result.success
3431 rajveer 982 
    if result.ucex is not None:
3032 mandeep.dh 983 
      raise result.ucex
984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
985 
 
559 chandransh 986 
  def createUser(self, user):
94 ashish 987 
    """
988 
    Parameters:
559 chandransh 989 
     - user
94 ashish 990 
    """
559 chandransh 991 
    self.send_createUser(user)
992 
    return self.recv_createUser()
94 ashish 993 
 
559 chandransh 994 
  def send_createUser(self, user):
995 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
996 
    args = createUser_args()
997 
    args.user = user
94 ashish 998 
    args.write(self._oprot)
999 
    self._oprot.writeMessageEnd()
1000 
    self._oprot.trans.flush()
1001 
 
559 chandransh 1002 
  def recv_createUser(self, ):
94 ashish 1003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1004 
    if mtype == TMessageType.EXCEPTION:
1005 
      x = TApplicationException()
1006 
      x.read(self._iprot)
1007 
      self._iprot.readMessageEnd()
1008 
      raise x
559 chandransh 1009 
    result = createUser_result()
94 ashish 1010 
    result.read(self._iprot)
1011 
    self._iprot.readMessageEnd()
3431 rajveer 1012 
    if result.success is not None:
94 ashish 1013 
      return result.success
3431 rajveer 1014 
    if result.ucex is not None:
559 chandransh 1015 
      raise result.ucex
1016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1017 
 
559 chandransh 1018 
  def updateUser(self, user):
94 ashish 1019 
    """
1020 
    Parameters:
559 chandransh 1021 
     - user
94 ashish 1022 
    """
559 chandransh 1023 
    self.send_updateUser(user)
1024 
    return self.recv_updateUser()
94 ashish 1025 
 
559 chandransh 1026 
  def send_updateUser(self, user):
1027 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1028 
    args = updateUser_args()
1029 
    args.user = user
94 ashish 1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
559 chandransh 1034 
  def recv_updateUser(self, ):
94 ashish 1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
559 chandransh 1041 
    result = updateUser_result()
94 ashish 1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
3431 rajveer 1044 
    if result.success is not None:
94 ashish 1045 
      return result.success
3431 rajveer 1046 
    if result.ucex is not None:
559 chandransh 1047 
      raise result.ucex
1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1049 
 
559 chandransh 1050 
  def authenticateUser(self, email, password):
94 ashish 1051 
    """
1052 
    Parameters:
1053 
     - email
1054 
     - password
1055 
    """
559 chandransh 1056 
    self.send_authenticateUser(email, password)
122 ashish 1057 
    return self.recv_authenticateUser()
1058 
 
559 chandransh 1059 
  def send_authenticateUser(self, email, password):
122 ashish 1060 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1061 
    args = authenticateUser_args()
559 chandransh 1062 
    args.email = email
122 ashish 1063 
    args.password = password
1064 
    args.write(self._oprot)
1065 
    self._oprot.writeMessageEnd()
1066 
    self._oprot.trans.flush()
1067 
 
1068 
  def recv_authenticateUser(self, ):
1069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1070 
    if mtype == TMessageType.EXCEPTION:
1071 
      x = TApplicationException()
1072 
      x.read(self._iprot)
1073 
      self._iprot.readMessageEnd()
1074 
      raise x
1075 
    result = authenticateUser_result()
1076 
    result.read(self._iprot)
1077 
    self._iprot.readMessageEnd()
3431 rajveer 1078 
    if result.success is not None:
122 ashish 1079 
      return result.success
3431 rajveer 1080 
    if result.auex is not None:
559 chandransh 1081 
      raise result.auex
122 ashish 1082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1083 
 
94 ashish 1084 
  def userExists(self, email):
1085 
    """
1086 
    Parameters:
1087 
     - email
1088 
    """
1089 
    self.send_userExists(email)
1090 
    return self.recv_userExists()
1091 
 
1092 
  def send_userExists(self, email):
1093 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1094 
    args = userExists_args()
1095 
    args.email = email
1096 
    args.write(self._oprot)
1097 
    self._oprot.writeMessageEnd()
1098 
    self._oprot.trans.flush()
1099 
 
1100 
  def recv_userExists(self, ):
1101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1102 
    if mtype == TMessageType.EXCEPTION:
1103 
      x = TApplicationException()
1104 
      x.read(self._iprot)
1105 
      self._iprot.readMessageEnd()
1106 
      raise x
1107 
    result = userExists_result()
1108 
    result.read(self._iprot)
1109 
    self._iprot.readMessageEnd()
3431 rajveer 1110 
    if result.success is not None:
94 ashish 1111 
      return result.success
3431 rajveer 1112 
    if result.ucx is not None:
94 ashish 1113 
      raise result.ucx
1114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1115 
 
567 rajveer 1116 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1117 
    """
1118 
    Parameters:
1119 
     - userId
1120 
     - address
513 rajveer 1121 
     - setDefault
94 ashish 1122 
    """
567 rajveer 1123 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1124 
    return self.recv_addAddressForUser()
1125 
 
567 rajveer 1126 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1127 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1128 
    args = addAddressForUser_args()
559 chandransh 1129 
    args.userId = userId
94 ashish 1130 
    args.address = address
513 rajveer 1131 
    args.setDefault = setDefault
94 ashish 1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
1136 
  def recv_addAddressForUser(self, ):
1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
1143 
    result = addAddressForUser_result()
1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
3431 rajveer 1146 
    if result.success is not None:
94 ashish 1147 
      return result.success
3431 rajveer 1148 
    if result.ucx is not None:
94 ashish 1149 
      raise result.ucx
1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1151 
 
1152 
  def removeAddressForUser(self, userid, addressId):
1153 
    """
1154 
    Parameters:
1155 
     - userid
1156 
     - addressId
1157 
    """
1158 
    self.send_removeAddressForUser(userid, addressId)
1159 
    return self.recv_removeAddressForUser()
1160 
 
1161 
  def send_removeAddressForUser(self, userid, addressId):
1162 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1163 
    args = removeAddressForUser_args()
1164 
    args.userid = userid
1165 
    args.addressId = addressId
1166 
    args.write(self._oprot)
1167 
    self._oprot.writeMessageEnd()
1168 
    self._oprot.trans.flush()
1169 
 
1170 
  def recv_removeAddressForUser(self, ):
1171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1172 
    if mtype == TMessageType.EXCEPTION:
1173 
      x = TApplicationException()
1174 
      x.read(self._iprot)
1175 
      self._iprot.readMessageEnd()
1176 
      raise x
1177 
    result = removeAddressForUser_result()
1178 
    result.read(self._iprot)
1179 
    self._iprot.readMessageEnd()
3431 rajveer 1180 
    if result.success is not None:
94 ashish 1181 
      return result.success
3431 rajveer 1182 
    if result.ucx is not None:
94 ashish 1183 
      raise result.ucx
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1185 
 
1186 
  def setUserAsLoggedIn(self, userId, timestamp):
1187 
    """
1188 
    Parameters:
1189 
     - userId
1190 
     - timestamp
1191 
    """
1192 
    self.send_setUserAsLoggedIn(userId, timestamp)
1193 
    return self.recv_setUserAsLoggedIn()
1194 
 
1195 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1196 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1197 
    args = setUserAsLoggedIn_args()
1198 
    args.userId = userId
1199 
    args.timestamp = timestamp
1200 
    args.write(self._oprot)
1201 
    self._oprot.writeMessageEnd()
1202 
    self._oprot.trans.flush()
1203 
 
1204 
  def recv_setUserAsLoggedIn(self, ):
1205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1206 
    if mtype == TMessageType.EXCEPTION:
1207 
      x = TApplicationException()
1208 
      x.read(self._iprot)
1209 
      self._iprot.readMessageEnd()
1210 
      raise x
1211 
    result = setUserAsLoggedIn_result()
1212 
    result.read(self._iprot)
1213 
    self._iprot.readMessageEnd()
3431 rajveer 1214 
    if result.success is not None:
94 ashish 1215 
      return result.success
3431 rajveer 1216 
    if result.ucx is not None:
94 ashish 1217 
      raise result.ucx
1218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1219 
 
1220 
  def setUserAsLoggedOut(self, userid, timestamp):
1221 
    """
1222 
    Parameters:
1223 
     - userid
1224 
     - timestamp
1225 
    """
1226 
    self.send_setUserAsLoggedOut(userid, timestamp)
1227 
    return self.recv_setUserAsLoggedOut()
1228 
 
1229 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1230 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1231 
    args = setUserAsLoggedOut_args()
1232 
    args.userid = userid
1233 
    args.timestamp = timestamp
1234 
    args.write(self._oprot)
1235 
    self._oprot.writeMessageEnd()
1236 
    self._oprot.trans.flush()
1237 
 
1238 
  def recv_setUserAsLoggedOut(self, ):
1239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1240 
    if mtype == TMessageType.EXCEPTION:
1241 
      x = TApplicationException()
1242 
      x.read(self._iprot)
1243 
      self._iprot.readMessageEnd()
1244 
      raise x
1245 
    result = setUserAsLoggedOut_result()
1246 
    result.read(self._iprot)
1247 
    self._iprot.readMessageEnd()
3431 rajveer 1248 
    if result.success is not None:
94 ashish 1249 
      return result.success
3431 rajveer 1250 
    if result.ucx is not None:
94 ashish 1251 
      raise result.ucx
1252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1253 
 
504 rajveer 1254 
  def setDefaultAddress(self, userid, addressId):
1255 
    """
1256 
    Parameters:
1257 
     - userid
1258 
     - addressId
1259 
    """
1260 
    self.send_setDefaultAddress(userid, addressId)
1261 
    return self.recv_setDefaultAddress()
1262 
 
1263 
  def send_setDefaultAddress(self, userid, addressId):
1264 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1265 
    args = setDefaultAddress_args()
1266 
    args.userid = userid
1267 
    args.addressId = addressId
1268 
    args.write(self._oprot)
1269 
    self._oprot.writeMessageEnd()
1270 
    self._oprot.trans.flush()
1271 
 
1272 
  def recv_setDefaultAddress(self, ):
1273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1274 
    if mtype == TMessageType.EXCEPTION:
1275 
      x = TApplicationException()
1276 
      x.read(self._iprot)
1277 
      self._iprot.readMessageEnd()
1278 
      raise x
1279 
    result = setDefaultAddress_result()
1280 
    result.read(self._iprot)
1281 
    self._iprot.readMessageEnd()
3431 rajveer 1282 
    if result.success is not None:
504 rajveer 1283 
      return result.success
3431 rajveer 1284 
    if result.ucx is not None:
504 rajveer 1285 
      raise result.ucx
1286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1287 
 
594 rajveer 1288 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1289 
    """
1290 
    Parameters:
1291 
     - userid
594 rajveer 1292 
     - oldPassword
1293 
     - newPassword
94 ashish 1294 
    """
594 rajveer 1295 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1296 
    return self.recv_updatePassword()
1297 
 
594 rajveer 1298 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1299 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1300 
    args = updatePassword_args()
1301 
    args.userid = userid
594 rajveer 1302 
    args.oldPassword = oldPassword
1303 
    args.newPassword = newPassword
94 ashish 1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_updatePassword(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = updatePassword_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
3431 rajveer 1318 
    if result.success is not None:
94 ashish 1319 
      return result.success
3431 rajveer 1320 
    if result.ucx is not None:
94 ashish 1321 
      raise result.ucx
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1323 
 
884 rajveer 1324 
  def forgotPassword(self, email, newPassword):
581 rajveer 1325 
    """
1326 
    Parameters:
1327 
     - email
884 rajveer 1328 
     - newPassword
581 rajveer 1329 
    """
884 rajveer 1330 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1331 
    return self.recv_forgotPassword()
1332 
 
884 rajveer 1333 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1334 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1335 
    args = forgotPassword_args()
1336 
    args.email = email
884 rajveer 1337 
    args.newPassword = newPassword
581 rajveer 1338 
    args.write(self._oprot)
1339 
    self._oprot.writeMessageEnd()
1340 
    self._oprot.trans.flush()
1341 
 
1342 
  def recv_forgotPassword(self, ):
1343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1344 
    if mtype == TMessageType.EXCEPTION:
1345 
      x = TApplicationException()
1346 
      x.read(self._iprot)
1347 
      self._iprot.readMessageEnd()
1348 
      raise x
1349 
    result = forgotPassword_result()
1350 
    result.read(self._iprot)
1351 
    self._iprot.readMessageEnd()
3431 rajveer 1352 
    if result.success is not None:
581 rajveer 1353 
      return result.success
3431 rajveer 1354 
    if result.ucx is not None:
581 rajveer 1355 
      raise result.ucx
1356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1357 
 
594 rajveer 1358 
  def getAllAddressesForUser(self, userId):
1359 
    """
1360 
    Parameters:
1361 
     - userId
1362 
    """
1363 
    self.send_getAllAddressesForUser(userId)
1364 
    return self.recv_getAllAddressesForUser()
1365 
 
1366 
  def send_getAllAddressesForUser(self, userId):
1367 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1368 
    args = getAllAddressesForUser_args()
1369 
    args.userId = userId
1370 
    args.write(self._oprot)
1371 
    self._oprot.writeMessageEnd()
1372 
    self._oprot.trans.flush()
1373 
 
1374 
  def recv_getAllAddressesForUser(self, ):
1375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1376 
    if mtype == TMessageType.EXCEPTION:
1377 
      x = TApplicationException()
1378 
      x.read(self._iprot)
1379 
      self._iprot.readMessageEnd()
1380 
      raise x
1381 
    result = getAllAddressesForUser_result()
1382 
    result.read(self._iprot)
1383 
    self._iprot.readMessageEnd()
3431 rajveer 1384 
    if result.success is not None:
594 rajveer 1385 
      return result.success
3431 rajveer 1386 
    if result.ucx is not None:
594 rajveer 1387 
      raise result.ucx
1388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1389 
 
1894 vikas 1390 
  def getAddressById(self, addressId):
1391 
    """
1392 
    Parameters:
1393 
     - addressId
1394 
    """
1395 
    self.send_getAddressById(addressId)
1396 
    return self.recv_getAddressById()
1397 
 
1398 
  def send_getAddressById(self, addressId):
1399 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1400 
    args = getAddressById_args()
1401 
    args.addressId = addressId
1402 
    args.write(self._oprot)
1403 
    self._oprot.writeMessageEnd()
1404 
    self._oprot.trans.flush()
1405 
 
1406 
  def recv_getAddressById(self, ):
1407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1408 
    if mtype == TMessageType.EXCEPTION:
1409 
      x = TApplicationException()
1410 
      x.read(self._iprot)
1411 
      self._iprot.readMessageEnd()
1412 
      raise x
1413 
    result = getAddressById_result()
1414 
    result.read(self._iprot)
1415 
    self._iprot.readMessageEnd()
3431 rajveer 1416 
    if result.success is not None:
1894 vikas 1417 
      return result.success
3431 rajveer 1418 
    if result.ucx is not None:
1894 vikas 1419 
      raise result.ucx
1420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1421 
 
594 rajveer 1422 
  def getDefaultAddressId(self, userId):
1423 
    """
1424 
    Parameters:
1425 
     - userId
1426 
    """
1427 
    self.send_getDefaultAddressId(userId)
1428 
    return self.recv_getDefaultAddressId()
1429 
 
1430 
  def send_getDefaultAddressId(self, userId):
1431 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1432 
    args = getDefaultAddressId_args()
1433 
    args.userId = userId
1434 
    args.write(self._oprot)
1435 
    self._oprot.writeMessageEnd()
1436 
    self._oprot.trans.flush()
1437 
 
1438 
  def recv_getDefaultAddressId(self, ):
1439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1440 
    if mtype == TMessageType.EXCEPTION:
1441 
      x = TApplicationException()
1442 
      x.read(self._iprot)
1443 
      self._iprot.readMessageEnd()
1444 
      raise x
1445 
    result = getDefaultAddressId_result()
1446 
    result.read(self._iprot)
1447 
    self._iprot.readMessageEnd()
3431 rajveer 1448 
    if result.success is not None:
594 rajveer 1449 
      return result.success
3431 rajveer 1450 
    if result.ucx is not None:
594 rajveer 1451 
      raise result.ucx
1452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1453 
 
785 rajveer 1454 
  def getDefaultPincode(self, userId):
1455 
    """
1456 
    Parameters:
1457 
     - userId
1458 
    """
1459 
    self.send_getDefaultPincode(userId)
1460 
    return self.recv_getDefaultPincode()
1461 
 
1462 
  def send_getDefaultPincode(self, userId):
1463 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1464 
    args = getDefaultPincode_args()
1465 
    args.userId = userId
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_getDefaultPincode(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = getDefaultPincode_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
3431 rajveer 1480 
    if result.success is not None:
785 rajveer 1481 
      return result.success
3431 rajveer 1482 
    if result.ucx is not None:
785 rajveer 1483 
      raise result.ucx
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1485 
 
1274 varun.gupt 1486 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1487 
    """
1488 
    Parameters:
1489 
     - userId
1490 
     - replyTo
1491 
     - communicationType
1492 
     - orderId
1493 
     - airwaybillNo
1494 
     - productName
1495 
     - subject
1496 
     - message
1497 
    """
1498 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1499 
    return self.recv_saveUserCommunication()
1500 
 
1501 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1502 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1503 
    args = saveUserCommunication_args()
1504 
    args.userId = userId
1505 
    args.replyTo = replyTo
1506 
    args.communicationType = communicationType
1507 
    args.orderId = orderId
1508 
    args.airwaybillNo = airwaybillNo
1509 
    args.productName = productName
1510 
    args.subject = subject
1511 
    args.message = message
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_saveUserCommunication(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = saveUserCommunication_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
3431 rajveer 1526 
    if result.success is not None:
1274 varun.gupt 1527 
      return result.success
3431 rajveer 1528 
    if result.ucx is not None:
1274 varun.gupt 1529 
      raise result.ucx
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1531 
 
1590 varun.gupt 1532 
  def getUserCommunicationById(self, id):
1533 
    """
1534 
    Parameters:
1535 
     - id
1536 
    """
1537 
    self.send_getUserCommunicationById(id)
1538 
    return self.recv_getUserCommunicationById()
1539 
 
1540 
  def send_getUserCommunicationById(self, id):
1541 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1542 
    args = getUserCommunicationById_args()
1543 
    args.id = id
1544 
    args.write(self._oprot)
1545 
    self._oprot.writeMessageEnd()
1546 
    self._oprot.trans.flush()
1547 
 
1548 
  def recv_getUserCommunicationById(self, ):
1549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1550 
    if mtype == TMessageType.EXCEPTION:
1551 
      x = TApplicationException()
1552 
      x.read(self._iprot)
1553 
      self._iprot.readMessageEnd()
1554 
      raise x
1555 
    result = getUserCommunicationById_result()
1556 
    result.read(self._iprot)
1557 
    self._iprot.readMessageEnd()
3431 rajveer 1558 
    if result.success is not None:
1590 varun.gupt 1559 
      return result.success
3431 rajveer 1560 
    if result.ucx is not None:
1590 varun.gupt 1561 
      raise result.ucx
1562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1563 
 
1564 
  def getUserCommunicationByUser(self, userId):
1565 
    """
1566 
    Parameters:
1567 
     - userId
1568 
    """
1569 
    self.send_getUserCommunicationByUser(userId)
1570 
    return self.recv_getUserCommunicationByUser()
1571 
 
1572 
  def send_getUserCommunicationByUser(self, userId):
1573 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1574 
    args = getUserCommunicationByUser_args()
1575 
    args.userId = userId
1576 
    args.write(self._oprot)
1577 
    self._oprot.writeMessageEnd()
1578 
    self._oprot.trans.flush()
1579 
 
1580 
  def recv_getUserCommunicationByUser(self, ):
1581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1582 
    if mtype == TMessageType.EXCEPTION:
1583 
      x = TApplicationException()
1584 
      x.read(self._iprot)
1585 
      self._iprot.readMessageEnd()
1586 
      raise x
1587 
    result = getUserCommunicationByUser_result()
1588 
    result.read(self._iprot)
1589 
    self._iprot.readMessageEnd()
3431 rajveer 1590 
    if result.success is not None:
1590 varun.gupt 1591 
      return result.success
3431 rajveer 1592 
    if result.ucx is not None:
1590 varun.gupt 1593 
      raise result.ucx
1594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1595 
 
1596 
  def getAllUserCommunications(self, ):
1597 
    self.send_getAllUserCommunications()
1598 
    return self.recv_getAllUserCommunications()
1599 
 
1600 
  def send_getAllUserCommunications(self, ):
1601 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1602 
    args = getAllUserCommunications_args()
1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
1607 
  def recv_getAllUserCommunications(self, ):
1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
1614 
    result = getAllUserCommunications_result()
1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
3431 rajveer 1617 
    if result.success is not None:
1590 varun.gupt 1618 
      return result.success
3431 rajveer 1619 
    if result.ucx is not None:
1590 varun.gupt 1620 
      raise result.ucx
1621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1622 
 
5407 amar.kumar 1623 
  def removeUserCommunication(self, id):
1624 
    """
1625 
    Parameters:
1626 
     - id
1627 
    """
1628 
    self.send_removeUserCommunication(id)
1629 
    self.recv_removeUserCommunication()
1630 
 
1631 
  def send_removeUserCommunication(self, id):
1632 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1633 
    args = removeUserCommunication_args()
1634 
    args.id = id
1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_removeUserCommunication(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = removeUserCommunication_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
1649 
    if result.ucx is not None:
1650 
      raise result.ucx
1651 
    return
1652 
 
1859 vikas 1653 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1654 
    """
1655 
    Parameters:
1656 
     - name
1859 vikas 1657 
     - addedOn
1845 vikas 1658 
    """
1859 vikas 1659 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1660 
    return self.recv_createMasterAffiliate()
1661 
 
1859 vikas 1662 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1663 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1664 
    args = createMasterAffiliate_args()
1665 
    args.name = name
1859 vikas 1666 
    args.addedOn = addedOn
1845 vikas 1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1671 
  def recv_createMasterAffiliate(self, ):
1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1678 
    result = createMasterAffiliate_result()
1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
3431 rajveer 1681 
    if result.success is not None:
1845 vikas 1682 
      return result.success
3431 rajveer 1683 
    if result.utx is not None:
1845 vikas 1684 
      raise result.utx
1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1686 
 
1899 vikas 1687 
  def getAllMasterAffiliates(self, ):
1688 
    self.send_getAllMasterAffiliates()
1689 
    return self.recv_getAllMasterAffiliates()
1690 
 
1691 
  def send_getAllMasterAffiliates(self, ):
1692 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1693 
    args = getAllMasterAffiliates_args()
1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1698 
  def recv_getAllMasterAffiliates(self, ):
1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1705 
    result = getAllMasterAffiliates_result()
1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
3431 rajveer 1708 
    if result.success is not None:
1899 vikas 1709 
      return result.success
3431 rajveer 1710 
    if result.utx is not None:
1899 vikas 1711 
      raise result.utx
1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1713 
 
1845 vikas 1714 
  def getMasterAffiliateById(self, id):
1715 
    """
1716 
    Parameters:
1717 
     - id
1718 
    """
1719 
    self.send_getMasterAffiliateById(id)
1720 
    return self.recv_getMasterAffiliateById()
1721 
 
1722 
  def send_getMasterAffiliateById(self, id):
1723 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1724 
    args = getMasterAffiliateById_args()
1725 
    args.id = id
1726 
    args.write(self._oprot)
1727 
    self._oprot.writeMessageEnd()
1728 
    self._oprot.trans.flush()
1729 
 
1730 
  def recv_getMasterAffiliateById(self, ):
1731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1732 
    if mtype == TMessageType.EXCEPTION:
1733 
      x = TApplicationException()
1734 
      x.read(self._iprot)
1735 
      self._iprot.readMessageEnd()
1736 
      raise x
1737 
    result = getMasterAffiliateById_result()
1738 
    result.read(self._iprot)
1739 
    self._iprot.readMessageEnd()
3431 rajveer 1740 
    if result.success is not None:
1845 vikas 1741 
      return result.success
3431 rajveer 1742 
    if result.utx is not None:
1845 vikas 1743 
      raise result.utx
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1745 
 
1746 
  def getMasterAffiliateByName(self, name):
1747 
    """
1748 
    Parameters:
1749 
     - name
1750 
    """
1751 
    self.send_getMasterAffiliateByName(name)
1752 
    return self.recv_getMasterAffiliateByName()
1753 
 
1754 
  def send_getMasterAffiliateByName(self, name):
1755 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1756 
    args = getMasterAffiliateByName_args()
1757 
    args.name = name
1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
1762 
  def recv_getMasterAffiliateByName(self, ):
1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
1769 
    result = getMasterAffiliateByName_result()
1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
3431 rajveer 1772 
    if result.success is not None:
1845 vikas 1773 
      return result.success
3431 rajveer 1774 
    if result.utx is not None:
1845 vikas 1775 
      raise result.utx
1776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1777 
 
1859 vikas 1778 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1779 
    """
1780 
    Parameters:
1781 
     - name
1782 
     - url
1783 
     - masterAffiliateId
1859 vikas 1784 
     - addedOn
1845 vikas 1785 
    """
1859 vikas 1786 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1787 
    return self.recv_createAffiliate()
1788 
 
1859 vikas 1789 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1790 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1791 
    args = createAffiliate_args()
1792 
    args.name = name
1793 
    args.url = url
1794 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1795 
    args.addedOn = addedOn
1845 vikas 1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
1800 
  def recv_createAffiliate(self, ):
1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
1807 
    result = createAffiliate_result()
1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
3431 rajveer 1810 
    if result.success is not None:
1845 vikas 1811 
      return result.success
3431 rajveer 1812 
    if result.utx is not None:
1845 vikas 1813 
      raise result.utx
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1815 
 
1816 
  def getAffiliateById(self, id):
1817 
    """
1818 
    Parameters:
1819 
     - id
1820 
    """
1821 
    self.send_getAffiliateById(id)
1822 
    return self.recv_getAffiliateById()
1823 
 
1824 
  def send_getAffiliateById(self, id):
1825 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1826 
    args = getAffiliateById_args()
1827 
    args.id = id
1828 
    args.write(self._oprot)
1829 
    self._oprot.writeMessageEnd()
1830 
    self._oprot.trans.flush()
1831 
 
1832 
  def recv_getAffiliateById(self, ):
1833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1834 
    if mtype == TMessageType.EXCEPTION:
1835 
      x = TApplicationException()
1836 
      x.read(self._iprot)
1837 
      self._iprot.readMessageEnd()
1838 
      raise x
1839 
    result = getAffiliateById_result()
1840 
    result.read(self._iprot)
1841 
    self._iprot.readMessageEnd()
3431 rajveer 1842 
    if result.success is not None:
1845 vikas 1843 
      return result.success
3431 rajveer 1844 
    if result.utx is not None:
1845 vikas 1845 
      raise result.utx
1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1847 
 
1848 
  def getAffiliateByName(self, name):
1849 
    """
1850 
    Parameters:
1851 
     - name
1852 
    """
1853 
    self.send_getAffiliateByName(name)
1854 
    return self.recv_getAffiliateByName()
1855 
 
1856 
  def send_getAffiliateByName(self, name):
1857 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1858 
    args = getAffiliateByName_args()
1859 
    args.name = name
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_getAffiliateByName(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = getAffiliateByName_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
3431 rajveer 1874 
    if result.success is not None:
1845 vikas 1875 
      return result.success
3431 rajveer 1876 
    if result.utx is not None:
1845 vikas 1877 
      raise result.utx
1878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1879 
 
1996 vikas 1880 
  def getTrackerById(self, id):
1845 vikas 1881 
    """
1882 
    Parameters:
1883 
     - id
1884 
    """
1996 vikas 1885 
    self.send_getTrackerById(id)
1845 vikas 1886 
    return self.recv_getTrackerById()
1887 
 
1996 vikas 1888 
  def send_getTrackerById(self, id):
1845 vikas 1889 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1890 
    args = getTrackerById_args()
1996 vikas 1891 
    args.id = id
1845 vikas 1892 
    args.write(self._oprot)
1893 
    self._oprot.writeMessageEnd()
1894 
    self._oprot.trans.flush()
1895 
 
1896 
  def recv_getTrackerById(self, ):
1897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1898 
    if mtype == TMessageType.EXCEPTION:
1899 
      x = TApplicationException()
1900 
      x.read(self._iprot)
1901 
      self._iprot.readMessageEnd()
1902 
      raise x
1903 
    result = getTrackerById_result()
1904 
    result.read(self._iprot)
1905 
    self._iprot.readMessageEnd()
3431 rajveer 1906 
    if result.success is not None:
1845 vikas 1907 
      return result.success
3431 rajveer 1908 
    if result.utx is not None:
1845 vikas 1909 
      raise result.utx
1910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1911 
 
1996 vikas 1912 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1913 
    """
1914 
    Parameters:
1996 vikas 1915 
     - id
1845 vikas 1916 
    """
1996 vikas 1917 
    self.send_getAffiliatesByMasterAffiliate(id)
1918 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1919 
 
1996 vikas 1920 
  def send_getAffiliatesByMasterAffiliate(self, id):
1921 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1922 
    args = getAffiliatesByMasterAffiliate_args()
1923 
    args.id = id
1845 vikas 1924 
    args.write(self._oprot)
1925 
    self._oprot.writeMessageEnd()
1926 
    self._oprot.trans.flush()
1927 
 
1996 vikas 1928 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1930 
    if mtype == TMessageType.EXCEPTION:
1931 
      x = TApplicationException()
1932 
      x.read(self._iprot)
1933 
      self._iprot.readMessageEnd()
1934 
      raise x
1996 vikas 1935 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1936 
    result.read(self._iprot)
1937 
    self._iprot.readMessageEnd()
3431 rajveer 1938 
    if result.success is not None:
1845 vikas 1939 
      return result.success
3431 rajveer 1940 
    if result.utx is not None:
1845 vikas 1941 
      raise result.utx
1996 vikas 1942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1943 
 
1996 vikas 1944 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1945 
    """
1946 
    Parameters:
1996 vikas 1947 
     - affiliateId
1845 vikas 1948 
     - userId
1949 
     - event
1950 
     - url
1951 
     - data
1859 vikas 1952 
     - addedOn
1845 vikas 1953 
    """
1996 vikas 1954 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1955 
    return self.recv_addTrackLog()
1956 
 
1996 vikas 1957 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1958 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1959 
    args = addTrackLog_args()
1996 vikas 1960 
    args.affiliateId = affiliateId
1845 vikas 1961 
    args.userId = userId
1962 
    args.event = event
1963 
    args.url = url
1964 
    args.data = data
1859 vikas 1965 
    args.addedOn = addedOn
1845 vikas 1966 
    args.write(self._oprot)
1967 
    self._oprot.writeMessageEnd()
1968 
    self._oprot.trans.flush()
1969 
 
1970 
  def recv_addTrackLog(self, ):
1971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1972 
    if mtype == TMessageType.EXCEPTION:
1973 
      x = TApplicationException()
1974 
      x.read(self._iprot)
1975 
      self._iprot.readMessageEnd()
1976 
      raise x
1977 
    result = addTrackLog_result()
1978 
    result.read(self._iprot)
1979 
    self._iprot.readMessageEnd()
3431 rajveer 1980 
    if result.success is not None:
1845 vikas 1981 
      return result.success
3431 rajveer 1982 
    if result.utx is not None:
1845 vikas 1983 
      raise result.utx
1984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1985 
 
1986 
  def getTrackLogById(self, id):
1987 
    """
1988 
    Parameters:
1989 
     - id
1990 
    """
1991 
    self.send_getTrackLogById(id)
1992 
    return self.recv_getTrackLogById()
1993 
 
1994 
  def send_getTrackLogById(self, id):
1995 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1996 
    args = getTrackLogById_args()
1997 
    args.id = id
1998 
    args.write(self._oprot)
1999 
    self._oprot.writeMessageEnd()
2000 
    self._oprot.trans.flush()
2001 
 
2002 
  def recv_getTrackLogById(self, ):
2003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2004 
    if mtype == TMessageType.EXCEPTION:
2005 
      x = TApplicationException()
2006 
      x.read(self._iprot)
2007 
      self._iprot.readMessageEnd()
2008 
      raise x
2009 
    result = getTrackLogById_result()
2010 
    result.read(self._iprot)
2011 
    self._iprot.readMessageEnd()
3431 rajveer 2012 
    if result.success is not None:
1845 vikas 2013 
      return result.success
3431 rajveer 2014 
    if result.utx is not None:
1845 vikas 2015 
      raise result.utx
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2017 
 
3293 vikas 2018 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2019 
    """
2020 
    Parameters:
1996 vikas 2021 
     - affiliateId
3293 vikas 2022 
     - startDate
2023 
     - endDate
1845 vikas 2024 
    """
3293 vikas 2025 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2026 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2027 
 
3293 vikas 2028 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2029 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2030 
    args = getTrackLogsByAffiliate_args()
2031 
    args.affiliateId = affiliateId
3293 vikas 2032 
    args.startDate = startDate
2033 
    args.endDate = endDate
1845 vikas 2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
1996 vikas 2038 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
1996 vikas 2045 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
3431 rajveer 2048 
    if result.success is not None:
1845 vikas 2049 
      return result.success
3431 rajveer 2050 
    if result.utx is not None:
1845 vikas 2051 
      raise result.utx
1996 vikas 2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2053 
 
2054 
  def getTrackLogsByUser(self, userId):
2055 
    """
2056 
    Parameters:
2057 
     - userId
2058 
    """
2059 
    self.send_getTrackLogsByUser(userId)
2060 
    return self.recv_getTrackLogsByUser()
2061 
 
2062 
  def send_getTrackLogsByUser(self, userId):
2063 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2064 
    args = getTrackLogsByUser_args()
2065 
    args.userId = userId
2066 
    args.write(self._oprot)
2067 
    self._oprot.writeMessageEnd()
2068 
    self._oprot.trans.flush()
2069 
 
2070 
  def recv_getTrackLogsByUser(self, ):
2071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2072 
    if mtype == TMessageType.EXCEPTION:
2073 
      x = TApplicationException()
2074 
      x.read(self._iprot)
2075 
      self._iprot.readMessageEnd()
2076 
      raise x
2077 
    result = getTrackLogsByUser_result()
2078 
    result.read(self._iprot)
2079 
    self._iprot.readMessageEnd()
3431 rajveer 2080 
    if result.success is not None:
1845 vikas 2081 
      return result.success
3431 rajveer 2082 
    if result.utx is not None:
1845 vikas 2083 
      raise result.utx
2084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2085 
 
1996 vikas 2086 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2087 
    """
2088 
    Parameters:
2089 
     - userId
2090 
     - event
2091 
     - url
2092 
    """
1996 vikas 2093 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2094 
    return self.recv_getTrackLogs()
2095 
 
1996 vikas 2096 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2097 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2098 
    args = getTrackLogs_args()
2099 
    args.userId = userId
2100 
    args.event = event
2101 
    args.url = url
2102 
    args.write(self._oprot)
2103 
    self._oprot.writeMessageEnd()
2104 
    self._oprot.trans.flush()
2105 
 
2106 
  def recv_getTrackLogs(self, ):
2107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2108 
    if mtype == TMessageType.EXCEPTION:
2109 
      x = TApplicationException()
2110 
      x.read(self._iprot)
2111 
      self._iprot.readMessageEnd()
2112 
      raise x
2113 
    result = getTrackLogs_result()
2114 
    result.read(self._iprot)
2115 
    self._iprot.readMessageEnd()
3431 rajveer 2116 
    if result.success is not None:
1845 vikas 2117 
      return result.success
3431 rajveer 2118 
    if result.utx is not None:
1845 vikas 2119 
      raise result.utx
2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2121 
 
559 chandransh 2122 
  def getCurrentCart(self, userId):
94 ashish 2123 
    """
2124 
    Parameters:
559 chandransh 2125 
     - userId
94 ashish 2126 
    """
559 chandransh 2127 
    self.send_getCurrentCart(userId)
2128 
    return self.recv_getCurrentCart()
94 ashish 2129 
 
559 chandransh 2130 
  def send_getCurrentCart(self, userId):
2131 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2132 
    args = getCurrentCart_args()
2133 
    args.userId = userId
94 ashish 2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
559 chandransh 2138 
  def recv_getCurrentCart(self, ):
94 ashish 2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
559 chandransh 2145 
    result = getCurrentCart_result()
94 ashish 2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
3431 rajveer 2148 
    if result.success is not None:
94 ashish 2149 
      return result.success
3431 rajveer 2150 
    if result.scx is not None:
559 chandransh 2151 
      raise result.scx
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2153 
 
559 chandransh 2154 
  def getCart(self, cartId):
94 ashish 2155 
    """
2156 
    Parameters:
559 chandransh 2157 
     - cartId
94 ashish 2158 
    """
559 chandransh 2159 
    self.send_getCart(cartId)
2160 
    return self.recv_getCart()
94 ashish 2161 
 
559 chandransh 2162 
  def send_getCart(self, cartId):
2163 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2164 
    args = getCart_args()
2165 
    args.cartId = cartId
94 ashish 2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
559 chandransh 2170 
  def recv_getCart(self, ):
94 ashish 2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
559 chandransh 2177 
    result = getCart_result()
94 ashish 2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
3431 rajveer 2180 
    if result.success is not None:
94 ashish 2181 
      return result.success
3431 rajveer 2182 
    if result.scx is not None:
559 chandransh 2183 
      raise result.scx
2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2185 
 
559 chandransh 2186 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2187 
    """
2188 
    Parameters:
559 chandransh 2189 
     - from_time
2190 
     - to_time
2191 
     - status
94 ashish 2192 
    """
559 chandransh 2193 
    self.send_getCartsByTime(from_time, to_time, status)
2194 
    return self.recv_getCartsByTime()
94 ashish 2195 
 
559 chandransh 2196 
  def send_getCartsByTime(self, from_time, to_time, status):
2197 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2198 
    args = getCartsByTime_args()
2199 
    args.from_time = from_time
2200 
    args.to_time = to_time
2201 
    args.status = status
94 ashish 2202 
    args.write(self._oprot)
2203 
    self._oprot.writeMessageEnd()
2204 
    self._oprot.trans.flush()
2205 
 
559 chandransh 2206 
  def recv_getCartsByTime(self, ):
94 ashish 2207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2208 
    if mtype == TMessageType.EXCEPTION:
2209 
      x = TApplicationException()
2210 
      x.read(self._iprot)
2211 
      self._iprot.readMessageEnd()
2212 
      raise x
559 chandransh 2213 
    result = getCartsByTime_result()
94 ashish 2214 
    result.read(self._iprot)
2215 
    self._iprot.readMessageEnd()
3431 rajveer 2216 
    if result.success is not None:
94 ashish 2217 
      return result.success
3431 rajveer 2218 
    if result.scx is not None:
559 chandransh 2219 
      raise result.scx
2220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2221 
 
3557 rajveer 2222 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2223 
    """
2224 
    Parameters:
2225 
     - cartId
2226 
     - itemId
2227 
     - quantity
3557 rajveer 2228 
     - sourceId
559 chandransh 2229 
    """
3557 rajveer 2230 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2231 
    return self.recv_addItemToCart()
559 chandransh 2232 
 
3557 rajveer 2233 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2234 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2235 
    args = addItemToCart_args()
2236 
    args.cartId = cartId
2237 
    args.itemId = itemId
2238 
    args.quantity = quantity
3557 rajveer 2239 
    args.sourceId = sourceId
559 chandransh 2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
2244 
  def recv_addItemToCart(self, ):
2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
2251 
    result = addItemToCart_result()
2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
3431 rajveer 2254 
    if result.success is not None:
2035 rajveer 2255 
      return result.success
3431 rajveer 2256 
    if result.scx is not None:
559 chandransh 2257 
      raise result.scx
2035 rajveer 2258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2259 
 
2260 
  def deleteItemFromCart(self, cartId, itemId):
2261 
    """
2262 
    Parameters:
2263 
     - cartId
2264 
     - itemId
2265 
    """
2266 
    self.send_deleteItemFromCart(cartId, itemId)
2267 
    self.recv_deleteItemFromCart()
2268 
 
2269 
  def send_deleteItemFromCart(self, cartId, itemId):
2270 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2271 
    args = deleteItemFromCart_args()
2272 
    args.cartId = cartId
2273 
    args.itemId = itemId
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_deleteItemFromCart(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = deleteItemFromCart_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
3431 rajveer 2288 
    if result.scx is not None:
559 chandransh 2289 
      raise result.scx
2290 
    return
2291 
 
2292 
  def addAddressToCart(self, cartId, addressId):
2293 
    """
2294 
    Parameters:
2295 
     - cartId
2296 
     - addressId
2297 
    """
2298 
    self.send_addAddressToCart(cartId, addressId)
2299 
    self.recv_addAddressToCart()
2300 
 
2301 
  def send_addAddressToCart(self, cartId, addressId):
2302 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2303 
    args = addAddressToCart_args()
2304 
    args.cartId = cartId
2305 
    args.addressId = addressId
2306 
    args.write(self._oprot)
2307 
    self._oprot.writeMessageEnd()
2308 
    self._oprot.trans.flush()
2309 
 
2310 
  def recv_addAddressToCart(self, ):
2311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2312 
    if mtype == TMessageType.EXCEPTION:
2313 
      x = TApplicationException()
2314 
      x.read(self._iprot)
2315 
      self._iprot.readMessageEnd()
2316 
      raise x
2317 
    result = addAddressToCart_result()
2318 
    result.read(self._iprot)
2319 
    self._iprot.readMessageEnd()
3431 rajveer 2320 
    if result.scx is not None:
575 chandransh 2321 
      raise result.scx
559 chandransh 2322 
    return
2323 
 
5553 rajveer 2324 
  def addStoreToCart(self, cartId, storeId):
2325 
    """
2326 
    Parameters:
2327 
     - cartId
2328 
     - storeId
2329 
    """
2330 
    self.send_addStoreToCart(cartId, storeId)
2331 
    self.recv_addStoreToCart()
2332 
 
2333 
  def send_addStoreToCart(self, cartId, storeId):
2334 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2335 
    args = addStoreToCart_args()
2336 
    args.cartId = cartId
2337 
    args.storeId = storeId
2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
2342 
  def recv_addStoreToCart(self, ):
2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
2349 
    result = addStoreToCart_result()
2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
2352 
    if result.scx is not None:
2353 
      raise result.scx
2354 
    return
2355 
 
6922 anupam.sin 2356 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2357 
    """
2358 
    Parameters:
6922 anupam.sin 2359 
     - cart
1976 varun.gupt 2360 
     - couponCode
2361 
    """
6922 anupam.sin 2362 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2363 
    self.recv_applyCouponToCart()
2364 
 
6922 anupam.sin 2365 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2366 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2367 
    args = applyCouponToCart_args()
6922 anupam.sin 2368 
    args.cart = cart
1976 varun.gupt 2369 
    args.couponCode = couponCode
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_applyCouponToCart(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = applyCouponToCart_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
3431 rajveer 2384 
    if result.scx is not None:
1976 varun.gupt 2385 
      raise result.scx
2386 
    return
2387 
 
2388 
  def removeCoupon(self, cartId):
2389 
    """
2390 
    Parameters:
2391 
     - cartId
2392 
    """
2393 
    self.send_removeCoupon(cartId)
2394 
    self.recv_removeCoupon()
2395 
 
2396 
  def send_removeCoupon(self, cartId):
2397 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2398 
    args = removeCoupon_args()
2399 
    args.cartId = cartId
2400 
    args.write(self._oprot)
2401 
    self._oprot.writeMessageEnd()
2402 
    self._oprot.trans.flush()
2403 
 
2404 
  def recv_removeCoupon(self, ):
2405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2406 
    if mtype == TMessageType.EXCEPTION:
2407 
      x = TApplicationException()
2408 
      x.read(self._iprot)
2409 
      self._iprot.readMessageEnd()
2410 
      raise x
2411 
    result = removeCoupon_result()
2412 
    result.read(self._iprot)
2413 
    self._iprot.readMessageEnd()
3431 rajveer 2414 
    if result.scx is not None:
1976 varun.gupt 2415 
      raise result.scx
2416 
    return
2417 
 
3554 varun.gupt 2418 
  def deleteDiscountsFromCart(self, cartId):
2419 
    """
2420 
    Deletes all the discounts associated with the cart
2421 
 
2422 
    Parameters:
2423 
     - cartId
2424 
    """
2425 
    self.send_deleteDiscountsFromCart(cartId)
2426 
    self.recv_deleteDiscountsFromCart()
2427 
 
2428 
  def send_deleteDiscountsFromCart(self, cartId):
2429 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2430 
    args = deleteDiscountsFromCart_args()
2431 
    args.cartId = cartId
2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
2436 
  def recv_deleteDiscountsFromCart(self, ):
2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
2443 
    result = deleteDiscountsFromCart_result()
2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
2446 
    if result.scx is not None:
2447 
      raise result.scx
2448 
    return
2449 
 
2450 
  def saveDiscounts(self, discounts):
2451 
    """
2452 
    Accepts a list of thrift objects of Discount type and saves them
2453 
 
2454 
    Parameters:
2455 
     - discounts
2456 
    """
2457 
    self.send_saveDiscounts(discounts)
2458 
    self.recv_saveDiscounts()
2459 
 
2460 
  def send_saveDiscounts(self, discounts):
2461 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2462 
    args = saveDiscounts_args()
2463 
    args.discounts = discounts
2464 
    args.write(self._oprot)
2465 
    self._oprot.writeMessageEnd()
2466 
    self._oprot.trans.flush()
2467 
 
2468 
  def recv_saveDiscounts(self, ):
2469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2470 
    if mtype == TMessageType.EXCEPTION:
2471 
      x = TApplicationException()
2472 
      x.read(self._iprot)
2473 
      self._iprot.readMessageEnd()
2474 
      raise x
2475 
    result = saveDiscounts_result()
2476 
    result.read(self._iprot)
2477 
    self._iprot.readMessageEnd()
2478 
    if result.scx is not None:
2479 
      raise result.scx
2480 
    return
2481 
 
21454 amit.gupta 2482 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
559 chandransh 2483 
    """
690 chandransh 2484 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2485 
 
559 chandransh 2486 
    Parameters:
2487 
     - cartId
2815 vikas 2488 
     - sessionSource
2489 
     - sessionStartTime
3858 vikas 2490 
     - firstSource
2491 
     - firstSourceTime
5326 rajveer 2492 
     - userId
6389 rajveer 2493 
     - schemeId
11526 amit.gupta 2494 
     - orderSource
21454 amit.gupta 2495 
     - selfPickup
559 chandransh 2496 
    """
21454 amit.gupta 2497 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup)
690 chandransh 2498 
    return self.recv_createOrders()
559 chandransh 2499 
 
21454 amit.gupta 2500 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource, selfPickup):
690 chandransh 2501 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2502 
    args = createOrders_args()
559 chandransh 2503 
    args.cartId = cartId
2815 vikas 2504 
    args.sessionSource = sessionSource
2505 
    args.sessionStartTime = sessionStartTime
3858 vikas 2506 
    args.firstSource = firstSource
2507 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2508 
    args.userId = userId
6389 rajveer 2509 
    args.schemeId = schemeId
11526 amit.gupta 2510 
    args.orderSource = orderSource
21454 amit.gupta 2511 
    args.selfPickup = selfPickup
559 chandransh 2512 
    args.write(self._oprot)
2513 
    self._oprot.writeMessageEnd()
2514 
    self._oprot.trans.flush()
2515 
 
690 chandransh 2516 
  def recv_createOrders(self, ):
559 chandransh 2517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2518 
    if mtype == TMessageType.EXCEPTION:
2519 
      x = TApplicationException()
2520 
      x.read(self._iprot)
2521 
      self._iprot.readMessageEnd()
2522 
      raise x
690 chandransh 2523 
    result = createOrders_result()
559 chandransh 2524 
    result.read(self._iprot)
2525 
    self._iprot.readMessageEnd()
3431 rajveer 2526 
    if result.success is not None:
130 ashish 2527 
      return result.success
3431 rajveer 2528 
    if result.scx is not None:
559 chandransh 2529 
      raise result.scx
690 chandransh 2530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2531 
 
3557 rajveer 2532 
  def validateCart(self, cartId, sourceId):
130 ashish 2533 
    """
690 chandransh 2534 
    Validates that:
2535 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2536 
    2. All of the lines in the cart are active items.
690 chandransh 2537 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2538 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2539 
 
130 ashish 2540 
    Parameters:
559 chandransh 2541 
     - cartId
3557 rajveer 2542 
     - sourceId
130 ashish 2543 
    """
3557 rajveer 2544 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2545 
    return self.recv_validateCart()
130 ashish 2546 
 
3557 rajveer 2547 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2548 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2549 
    args = validateCart_args()
2550 
    args.cartId = cartId
3557 rajveer 2551 
    args.sourceId = sourceId
130 ashish 2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
559 chandransh 2556 
  def recv_validateCart(self, ):
130 ashish 2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
559 chandransh 2563 
    result = validateCart_result()
130 ashish 2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
3431 rajveer 2566 
    if result.success is not None:
130 ashish 2567 
      return result.success
3431 rajveer 2568 
    if result.scex is not None:
575 chandransh 2569 
      raise result.scex
559 chandransh 2570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2571 
 
11980 amit.gupta 2572 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2573 
    """
2574 
    Validates that:
2575 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2576 
    2. All of the lines in the cart are active items.
2577 
    3. The estimate for any of the lines in cart doesn't change.
2578 
    If all three are true, returns empty string; else returns appropriate message.
2579 
 
2580 
    Parameters:
2581 
     - cartId
2582 
     - sourceId
2583 
     - dealCoupon
2584 
    """
2585 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2586 
    return self.recv_validateCartWithDealerCoupon()
2587 
 
2588 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2589 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2590 
    args = validateCartWithDealerCoupon_args()
2591 
    args.cartId = cartId
2592 
    args.sourceId = sourceId
2593 
    args.dealCoupon = dealCoupon
2594 
    args.write(self._oprot)
2595 
    self._oprot.writeMessageEnd()
2596 
    self._oprot.trans.flush()
2597 
 
2598 
  def recv_validateCartWithDealerCoupon(self, ):
2599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2600 
    if mtype == TMessageType.EXCEPTION:
2601 
      x = TApplicationException()
2602 
      x.read(self._iprot)
2603 
      self._iprot.readMessageEnd()
2604 
      raise x
2605 
    result = validateCartWithDealerCoupon_result()
2606 
    result.read(self._iprot)
2607 
    self._iprot.readMessageEnd()
2608 
    if result.success is not None:
2609 
      return result.success
2610 
    if result.scex is not None:
2611 
      raise result.scex
2612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2613 
 
690 chandransh 2614 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2615 
    """
690 chandransh 2616 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2617 
 
575 chandransh 2618 
    Parameters:
690 chandransh 2619 
     - fromCartId
2620 
     - toCartId
2621 
    """
2622 
    self.send_mergeCart(fromCartId, toCartId)
2623 
    self.recv_mergeCart()
2624 
 
2625 
  def send_mergeCart(self, fromCartId, toCartId):
2626 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2627 
    args = mergeCart_args()
2628 
    args.fromCartId = fromCartId
2629 
    args.toCartId = toCartId
2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
2634 
  def recv_mergeCart(self, ):
2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
2641 
    result = mergeCart_result()
2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
2644 
    return
2645 
 
2646 
  def checkOut(self, cartId):
2647 
    """
2648 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2649 
 
690 chandransh 2650 
    Parameters:
575 chandransh 2651 
     - cartId
2652 
    """
690 chandransh 2653 
    self.send_checkOut(cartId)
2654 
    return self.recv_checkOut()
575 chandransh 2655 
 
690 chandransh 2656 
  def send_checkOut(self, cartId):
2657 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2658 
    args = checkOut_args()
575 chandransh 2659 
    args.cartId = cartId
2660 
    args.write(self._oprot)
2661 
    self._oprot.writeMessageEnd()
2662 
    self._oprot.trans.flush()
2663 
 
690 chandransh 2664 
  def recv_checkOut(self, ):
575 chandransh 2665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2666 
    if mtype == TMessageType.EXCEPTION:
2667 
      x = TApplicationException()
2668 
      x.read(self._iprot)
2669 
      self._iprot.readMessageEnd()
2670 
      raise x
690 chandransh 2671 
    result = checkOut_result()
575 chandransh 2672 
    result.read(self._iprot)
2673 
    self._iprot.readMessageEnd()
3431 rajveer 2674 
    if result.success is not None:
575 chandransh 2675 
      return result.success
3431 rajveer 2676 
    if result.scex is not None:
575 chandransh 2677 
      raise result.scex
690 chandransh 2678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2679 
 
690 chandransh 2680 
  def resetCart(self, cartId, items):
559 chandransh 2681 
    """
690 chandransh 2682 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2683 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2684 
 
559 chandransh 2685 
    Parameters:
690 chandransh 2686 
     - cartId
2687 
     - items
559 chandransh 2688 
    """
690 chandransh 2689 
    self.send_resetCart(cartId, items)
2690 
    return self.recv_resetCart()
130 ashish 2691 
 
690 chandransh 2692 
  def send_resetCart(self, cartId, items):
2693 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2694 
    args = resetCart_args()
2695 
    args.cartId = cartId
2696 
    args.items = items
559 chandransh 2697 
    args.write(self._oprot)
2698 
    self._oprot.writeMessageEnd()
2699 
    self._oprot.trans.flush()
2700 
 
690 chandransh 2701 
  def recv_resetCart(self, ):
559 chandransh 2702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2703 
    if mtype == TMessageType.EXCEPTION:
2704 
      x = TApplicationException()
2705 
      x.read(self._iprot)
2706 
      self._iprot.readMessageEnd()
2707 
      raise x
690 chandransh 2708 
    result = resetCart_result()
559 chandransh 2709 
    result.read(self._iprot)
2710 
    self._iprot.readMessageEnd()
3431 rajveer 2711 
    if result.success is not None:
690 chandransh 2712 
      return result.success
3431 rajveer 2713 
    if result.scex is not None:
690 chandransh 2714 
      raise result.scex
2715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2716 
 
2981 rajveer 2717 
  def getUserCount(self, userType):
559 chandransh 2718 
    """
2981 rajveer 2719 
    Returns number of registered users.
2720 
    If userType = null, then it returns count of all users, including anonymous
2721 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2722 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2723 
 
559 chandransh 2724 
    Parameters:
2981 rajveer 2725 
     - userType
559 chandransh 2726 
    """
2981 rajveer 2727 
    self.send_getUserCount(userType)
2728 
    return self.recv_getUserCount()
559 chandransh 2729 
 
2981 rajveer 2730 
  def send_getUserCount(self, userType):
2731 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2732 
    args = getUserCount_args()
2733 
    args.userType = userType
559 chandransh 2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2981 rajveer 2738 
  def recv_getUserCount(self, ):
559 chandransh 2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2981 rajveer 2745 
    result = getUserCount_result()
559 chandransh 2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
3431 rajveer 2748 
    if result.success is not None:
559 chandransh 2749 
      return result.success
2981 rajveer 2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2751 
 
2981 rajveer 2752 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2753 
    """
2981 rajveer 2754 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2755 
    If any of startDate or endDate is -1, then that filter is ignored.
2756 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2757 
 
2758 
 
559 chandransh 2759 
    Parameters:
2981 rajveer 2760 
     - userType
2761 
     - startDate
2762 
     - endDate
559 chandransh 2763 
    """
2981 rajveer 2764 
    self.send_getAllUsers(userType, startDate, endDate)
2765 
    return self.recv_getAllUsers()
559 chandransh 2766 
 
2981 rajveer 2767 
  def send_getAllUsers(self, userType, startDate, endDate):
2768 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2769 
    args = getAllUsers_args()
2770 
    args.userType = userType
2771 
    args.startDate = startDate
2772 
    args.endDate = endDate
559 chandransh 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2981 rajveer 2777 
  def recv_getAllUsers(self, ):
559 chandransh 2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2981 rajveer 2784 
    result = getAllUsers_result()
559 chandransh 2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
3431 rajveer 2787 
    if result.success is not None:
559 chandransh 2788 
      return result.success
2981 rajveer 2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2790 
 
2981 rajveer 2791 
  def getMyResearchItems(self, userId):
559 chandransh 2792 
    """
2981 rajveer 2793 
    Returns list of item ids in myresearch for the user
3431 rajveer 2794 
 
559 chandransh 2795 
    Parameters:
772 rajveer 2796 
     - userId
559 chandransh 2797 
    """
2981 rajveer 2798 
    self.send_getMyResearchItems(userId)
2799 
    return self.recv_getMyResearchItems()
559 chandransh 2800 
 
2981 rajveer 2801 
  def send_getMyResearchItems(self, userId):
2802 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2803 
    args = getMyResearchItems_args()
772 rajveer 2804 
    args.userId = userId
559 chandransh 2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
2981 rajveer 2809 
  def recv_getMyResearchItems(self, ):
559 chandransh 2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
2981 rajveer 2816 
    result = getMyResearchItems_result()
559 chandransh 2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
3431 rajveer 2819 
    if result.success is not None:
559 chandransh 2820 
      return result.success
3431 rajveer 2821 
    if result.scx is not None:
559 chandransh 2822 
      raise result.scx
2981 rajveer 2823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2824 
 
2981 rajveer 2825 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2826 
    """
2981 rajveer 2827 
    add item to my research for a user
3431 rajveer 2828 
 
559 chandransh 2829 
    Parameters:
2981 rajveer 2830 
     - userId
2831 
     - itemId
559 chandransh 2832 
    """
2981 rajveer 2833 
    self.send_updateMyResearch(userId, itemId)
2834 
    return self.recv_updateMyResearch()
559 chandransh 2835 
 
2981 rajveer 2836 
  def send_updateMyResearch(self, userId, itemId):
2837 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2838 
    args = updateMyResearch_args()
2839 
    args.userId = userId
2840 
    args.itemId = itemId
559 chandransh 2841 
    args.write(self._oprot)
2842 
    self._oprot.writeMessageEnd()
2843 
    self._oprot.trans.flush()
2844 
 
2981 rajveer 2845 
  def recv_updateMyResearch(self, ):
559 chandransh 2846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2847 
    if mtype == TMessageType.EXCEPTION:
2848 
      x = TApplicationException()
2849 
      x.read(self._iprot)
2850 
      self._iprot.readMessageEnd()
2851 
      raise x
2981 rajveer 2852 
    result = updateMyResearch_result()
559 chandransh 2853 
    result.read(self._iprot)
2854 
    self._iprot.readMessageEnd()
3431 rajveer 2855 
    if result.success is not None:
2981 rajveer 2856 
      return result.success
3431 rajveer 2857 
    if result.scx is not None:
2981 rajveer 2858 
      raise result.scx
2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2860 
 
2981 rajveer 2861 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2862 
    """
2981 rajveer 2863 
    delete item from my research for a user
3431 rajveer 2864 
 
1596 ankur.sing 2865 
    Parameters:
2981 rajveer 2866 
     - userId
2867 
     - itemId
1596 ankur.sing 2868 
    """
2981 rajveer 2869 
    self.send_deleteItemFromMyResearch(userId, itemId)
2870 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2871 
 
2981 rajveer 2872 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2873 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2874 
    args = deleteItemFromMyResearch_args()
2875 
    args.userId = userId
2876 
    args.itemId = itemId
1596 ankur.sing 2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
2981 rajveer 2881 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
2981 rajveer 2888 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
3431 rajveer 2891 
    if result.scx is not None:
2981 rajveer 2892 
      raise result.scx
2893 
    return
1596 ankur.sing 2894 
 
2981 rajveer 2895 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2896 
    """
2981 rajveer 2897 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2898 
 
1673 ankur.sing 2899 
    Parameters:
2981 rajveer 2900 
     - userId
1673 ankur.sing 2901 
    """
2981 rajveer 2902 
    self.send_getBrowseHistoryItems(userId)
2903 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2904 
 
2981 rajveer 2905 
  def send_getBrowseHistoryItems(self, userId):
2906 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2907 
    args = getBrowseHistoryItems_args()
2908 
    args.userId = userId
1673 ankur.sing 2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2981 rajveer 2913 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2981 rajveer 2920 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
3431 rajveer 2923 
    if result.success is not None:
1673 ankur.sing 2924 
      return result.success
3431 rajveer 2925 
    if result.scx is not None:
2981 rajveer 2926 
      raise result.scx
2927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2928 
 
2981 rajveer 2929 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2930 
    """
2981 rajveer 2931 
    add item to browse history for a user
3431 rajveer 2932 
 
2642 varun.gupt 2933 
    Parameters:
2981 rajveer 2934 
     - userId
2935 
     - itemId
2642 varun.gupt 2936 
    """
2981 rajveer 2937 
    self.send_updateBrowseHistory(userId, itemId)
2938 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2939 
 
2981 rajveer 2940 
  def send_updateBrowseHistory(self, userId, itemId):
2941 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2942 
    args = updateBrowseHistory_args()
2943 
    args.userId = userId
2944 
    args.itemId = itemId
2642 varun.gupt 2945 
    args.write(self._oprot)
2946 
    self._oprot.writeMessageEnd()
2947 
    self._oprot.trans.flush()
2948 
 
2981 rajveer 2949 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2951 
    if mtype == TMessageType.EXCEPTION:
2952 
      x = TApplicationException()
2953 
      x.read(self._iprot)
2954 
      self._iprot.readMessageEnd()
2955 
      raise x
2981 rajveer 2956 
    result = updateBrowseHistory_result()
2642 varun.gupt 2957 
    result.read(self._iprot)
2958 
    self._iprot.readMessageEnd()
2959 
    return
2960 
 
3385 varun.gupt 2961 
  def getCartsWithCouponCount(self, couponCode):
2962 
    """
2963 
    Returns count of Carts with given coupon applied
3431 rajveer 2964 
 
3385 varun.gupt 2965 
    Parameters:
2966 
     - couponCode
2967 
    """
2968 
    self.send_getCartsWithCouponCount(couponCode)
2969 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2970 
 
3385 varun.gupt 2971 
  def send_getCartsWithCouponCount(self, couponCode):
2972 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2973 
    args = getCartsWithCouponCount_args()
2974 
    args.couponCode = couponCode
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_getCartsWithCouponCount(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = getCartsWithCouponCount_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
3431 rajveer 2989 
    if result.success is not None:
3385 varun.gupt 2990 
      return result.success
2991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2992 
 
3499 mandeep.dh 2993 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2994 
    """
2995 
    Updates COD trust level of a user
3385 varun.gupt 2996 
 
3499 mandeep.dh 2997 
    Parameters:
2998 
     - userId
2999 
     - trustLevelDelta
3000 
    """
3001 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
3002 
 
3003 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
3004 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
3005 
    args = increaseTrustLevel_args()
3006 
    args.userId = userId
3007 
    args.trustLevelDelta = trustLevelDelta
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
5407 amar.kumar 3011 
  def getTrustLevel(self, userId):
3012 
    """
3013 
    Get trust level of a user
3014 
 
3015 
    Parameters:
3016 
     - userId
3017 
    """
3018 
    self.send_getTrustLevel(userId)
3019 
    return self.recv_getTrustLevel()
3020 
 
3021 
  def send_getTrustLevel(self, userId):
3022 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3023 
    args = getTrustLevel_args()
3024 
    args.userId = userId
3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
3029 
  def recv_getTrustLevel(self, ):
3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
3036 
    result = getTrustLevel_result()
3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3039 
    if result.success is not None:
3040 
      return result.success
3041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3042 
 
4668 varun.gupt 3043 
  def showCODOption(self, cartId, sourceId, pincode):
3044 
    """
3045 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3046 
 
4668 varun.gupt 3047 
    Parameters:
3048 
     - cartId
3049 
     - sourceId
3050 
     - pincode
3051 
    """
3052 
    self.send_showCODOption(cartId, sourceId, pincode)
3053 
    return self.recv_showCODOption()
3054 
 
3055 
  def send_showCODOption(self, cartId, sourceId, pincode):
3056 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3057 
    args = showCODOption_args()
3058 
    args.cartId = cartId
3059 
    args.sourceId = sourceId
3060 
    args.pincode = pincode
3061 
    args.write(self._oprot)
3062 
    self._oprot.writeMessageEnd()
3063 
    self._oprot.trans.flush()
3064 
 
3065 
  def recv_showCODOption(self, ):
3066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3067 
    if mtype == TMessageType.EXCEPTION:
3068 
      x = TApplicationException()
3069 
      x.read(self._iprot)
3070 
      self._iprot.readMessageEnd()
3071 
      raise x
3072 
    result = showCODOption_result()
3073 
    result.read(self._iprot)
3074 
    self._iprot.readMessageEnd()
3075 
    if result.success is not None:
3076 
      return result.success
3077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3078 
 
5623 anupam.sin 3079 
  def getUserEmails(self, startDate, endDate):
3080 
    """
3081 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3082 
 
5623 anupam.sin 3083 
    Parameters:
3084 
     - startDate
3085 
     - endDate
3086 
    """
3087 
    self.send_getUserEmails(startDate, endDate)
3088 
    return self.recv_getUserEmails()
3089 
 
3090 
  def send_getUserEmails(self, startDate, endDate):
3091 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3092 
    args = getUserEmails_args()
3093 
    args.startDate = startDate
3094 
    args.endDate = endDate
3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3099 
  def recv_getUserEmails(self, ):
3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3106 
    result = getUserEmails_result()
3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
3109 
    if result.success is not None:
3110 
      return result.success
3111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3112 
 
9299 kshitij.so 3113 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3114 
    """
3115 
    Mark a cart lineitem as insured. Returns true/false.
3116 
 
3117 
    Parameters:
3118 
     - itemId
3119 
     - cartId
3120 
     - toInsure
9299 kshitij.so 3121 
     - insurerType
6903 anupam.sin 3122 
    """
9299 kshitij.so 3123 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3124 
    return self.recv_insureItem()
3125 
 
9299 kshitij.so 3126 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3127 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3128 
    args = insureItem_args()
3129 
    args.itemId = itemId
3130 
    args.cartId = cartId
3131 
    args.toInsure = toInsure
9299 kshitij.so 3132 
    args.insurerType = insurerType
6903 anupam.sin 3133 
    args.write(self._oprot)
3134 
    self._oprot.writeMessageEnd()
3135 
    self._oprot.trans.flush()
3136 
 
3137 
  def recv_insureItem(self, ):
3138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3139 
    if mtype == TMessageType.EXCEPTION:
3140 
      x = TApplicationException()
3141 
      x.read(self._iprot)
3142 
      self._iprot.readMessageEnd()
3143 
      raise x
3144 
    result = insureItem_result()
3145 
    result.read(self._iprot)
3146 
    self._iprot.readMessageEnd()
3147 
    if result.success is not None:
3148 
      return result.success
3149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3150 
 
3151 
  def cancelInsurance(self, cartId):
3152 
    """
3153 
    Cancel insurance for all items in the cart
3154 
 
3155 
    Parameters:
3156 
     - cartId
3157 
    """
3158 
    self.send_cancelInsurance(cartId)
3159 
    return self.recv_cancelInsurance()
3160 
 
3161 
  def send_cancelInsurance(self, cartId):
3162 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3163 
    args = cancelInsurance_args()
3164 
    args.cartId = cartId
3165 
    args.write(self._oprot)
3166 
    self._oprot.writeMessageEnd()
3167 
    self._oprot.trans.flush()
3168 
 
3169 
  def recv_cancelInsurance(self, ):
3170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3171 
    if mtype == TMessageType.EXCEPTION:
3172 
      x = TApplicationException()
3173 
      x.read(self._iprot)
3174 
      self._iprot.readMessageEnd()
3175 
      raise x
3176 
    result = cancelInsurance_result()
3177 
    result.read(self._iprot)
3178 
    self._iprot.readMessageEnd()
3179 
    if result.success is not None:
3180 
      return result.success
3181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3182 
 
3183 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3184 
    """
3185 
    Stores insurance specific details like date of birth and guardianName
3186 
 
3187 
    Parameters:
3188 
     - addressId
3189 
     - dob
3190 
     - guardianName
3191 
    """
3192 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3193 
    return self.recv_storeInsuranceSpecificDetails()
3194 
 
3195 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3196 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3197 
    args = storeInsuranceSpecificDetails_args()
3198 
    args.addressId = addressId
3199 
    args.dob = dob
3200 
    args.guardianName = guardianName
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_storeInsuranceSpecificDetails(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = storeInsuranceSpecificDetails_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
3217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3218 
 
3219 
  def isInsuranceDetailPresent(self, addressId):
3220 
    """
3221 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3222 
 
3223 
    Parameters:
3224 
     - addressId
3225 
    """
3226 
    self.send_isInsuranceDetailPresent(addressId)
3227 
    return self.recv_isInsuranceDetailPresent()
3228 
 
3229 
  def send_isInsuranceDetailPresent(self, addressId):
3230 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3231 
    args = isInsuranceDetailPresent_args()
3232 
    args.addressId = addressId
3233 
    args.write(self._oprot)
3234 
    self._oprot.writeMessageEnd()
3235 
    self._oprot.trans.flush()
3236 
 
3237 
  def recv_isInsuranceDetailPresent(self, ):
3238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3239 
    if mtype == TMessageType.EXCEPTION:
3240 
      x = TApplicationException()
3241 
      x.read(self._iprot)
3242 
      self._iprot.readMessageEnd()
3243 
      raise x
3244 
    result = isInsuranceDetailPresent_result()
3245 
    result.read(self._iprot)
3246 
    self._iprot.readMessageEnd()
3247 
    if result.success is not None:
3248 
      return result.success
3249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3250 
 
9791 rajveer 3251 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3252 
    """
9791 rajveer 3253 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3254 
 
6821 amar.kumar 3255 
    Parameters:
3256 
     - startDate
3257 
     - endDate
3258 
    """
9791 rajveer 3259 
    self.send_getProductsAddedToCart(startDate, endDate)
3260 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3261 
 
9791 rajveer 3262 
  def send_getProductsAddedToCart(self, startDate, endDate):
3263 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3264 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3265 
    args.startDate = startDate
3266 
    args.endDate = endDate
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
9791 rajveer 3271 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
9791 rajveer 3278 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.success is not None:
3282 
      return result.success
9791 rajveer 3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3284 
 
11980 amit.gupta 3285 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3286 
    """
3287 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3288 
 
11592 amit.gupta 3289 
    Parameters:
3290 
     - cartId
3291 
     - sourceId
11980 amit.gupta 3292 
     - dealerCoupon
11592 amit.gupta 3293 
    """
11980 amit.gupta 3294 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3295 
    return self.recv_validateCartPlus()
3296 
 
11980 amit.gupta 3297 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3298 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3299 
    args = validateCartPlus_args()
3300 
    args.cartId = cartId
3301 
    args.sourceId = sourceId
11980 amit.gupta 3302 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3303 
    args.write(self._oprot)
3304 
    self._oprot.writeMessageEnd()
3305 
    self._oprot.trans.flush()
3306 
 
3307 
  def recv_validateCartPlus(self, ):
3308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3309 
    if mtype == TMessageType.EXCEPTION:
3310 
      x = TApplicationException()
3311 
      x.read(self._iprot)
3312 
      self._iprot.readMessageEnd()
3313 
      raise x
3314 
    result = validateCartPlus_result()
3315 
    result.read(self._iprot)
3316 
    self._iprot.readMessageEnd()
3317 
    if result.success is not None:
3318 
      return result.success
3319 
    if result.scex is not None:
3320 
      raise result.scex
3321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3322 
 
11679 vikram.rag 3323 
  def isPrivateDealUser(self, userId):
3324 
    """
3325 
    Parameters:
3326 
     - userId
3327 
    """
3328 
    self.send_isPrivateDealUser(userId)
3329 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3330 
 
11679 vikram.rag 3331 
  def send_isPrivateDealUser(self, userId):
3332 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3333 
    args = isPrivateDealUser_args()
3334 
    args.userId = userId
3335 
    args.write(self._oprot)
3336 
    self._oprot.writeMessageEnd()
3337 
    self._oprot.trans.flush()
3338 
 
3339 
  def recv_isPrivateDealUser(self, ):
3340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3341 
    if mtype == TMessageType.EXCEPTION:
3342 
      x = TApplicationException()
3343 
      x.read(self._iprot)
3344 
      self._iprot.readMessageEnd()
3345 
      raise x
3346 
    result = isPrivateDealUser_result()
3347 
    result.read(self._iprot)
3348 
    self._iprot.readMessageEnd()
3349 
    if result.success is not None:
3350 
      return result.success
3351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3352 
 
11890 kshitij.so 3353 
  def addPrivateDealUser(self, userId):
3354 
    """
3355 
    Parameters:
3356 
     - userId
3357 
    """
3358 
    self.send_addPrivateDealUser(userId)
3359 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3360 
 
11890 kshitij.so 3361 
  def send_addPrivateDealUser(self, userId):
3362 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3363 
    args = addPrivateDealUser_args()
3364 
    args.userId = userId
3365 
    args.write(self._oprot)
3366 
    self._oprot.writeMessageEnd()
3367 
    self._oprot.trans.flush()
3368 
 
3369 
  def recv_addPrivateDealUser(self, ):
3370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3371 
    if mtype == TMessageType.EXCEPTION:
3372 
      x = TApplicationException()
3373 
      x.read(self._iprot)
3374 
      self._iprot.readMessageEnd()
3375 
      raise x
3376 
    result = addPrivateDealUser_result()
3377 
    result.read(self._iprot)
3378 
    self._iprot.readMessageEnd()
3379 
    if result.success is not None:
3380 
      return result.success
3381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3382 
 
3383 
  def changePrivateDealUserStatus(self, userId, isActive):
3384 
    """
3385 
    Parameters:
3386 
     - userId
3387 
     - isActive
3388 
    """
3389 
    self.send_changePrivateDealUserStatus(userId, isActive)
3390 
    return self.recv_changePrivateDealUserStatus()
3391 
 
3392 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3393 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3394 
    args = changePrivateDealUserStatus_args()
3395 
    args.userId = userId
3396 
    args.isActive = isActive
3397 
    args.write(self._oprot)
3398 
    self._oprot.writeMessageEnd()
3399 
    self._oprot.trans.flush()
3400 
 
3401 
  def recv_changePrivateDealUserStatus(self, ):
3402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3403 
    if mtype == TMessageType.EXCEPTION:
3404 
      x = TApplicationException()
3405 
      x.read(self._iprot)
3406 
      self._iprot.readMessageEnd()
3407 
      raise x
3408 
    result = changePrivateDealUserStatus_result()
3409 
    result.read(self._iprot)
3410 
    self._iprot.readMessageEnd()
3411 
    if result.success is not None:
3412 
      return result.success
3413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3414 
 
3415 
  def getPrivateDealUser(self, userId):
3416 
    """
3417 
    Parameters:
3418 
     - userId
3419 
    """
3420 
    self.send_getPrivateDealUser(userId)
3421 
    return self.recv_getPrivateDealUser()
3422 
 
3423 
  def send_getPrivateDealUser(self, userId):
3424 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3425 
    args = getPrivateDealUser_args()
3426 
    args.userId = userId
3427 
    args.write(self._oprot)
3428 
    self._oprot.writeMessageEnd()
3429 
    self._oprot.trans.flush()
3430 
 
3431 
  def recv_getPrivateDealUser(self, ):
3432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3433 
    if mtype == TMessageType.EXCEPTION:
3434 
      x = TApplicationException()
3435 
      x.read(self._iprot)
3436 
      self._iprot.readMessageEnd()
3437 
      raise x
3438 
    result = getPrivateDealUser_result()
3439 
    result.read(self._iprot)
3440 
    self._iprot.readMessageEnd()
3441 
    if result.success is not None:
3442 
      return result.success
3443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3444 
 
12696 amit.gupta 3445 
  def registerCounter(self, counter, userId):
3446 
    """
3447 
    Parameters:
3448 
     - counter
3449 
     - userId
3450 
    """
3451 
    self.send_registerCounter(counter, userId)
3452 
    return self.recv_registerCounter()
11890 kshitij.so 3453 
 
12696 amit.gupta 3454 
  def send_registerCounter(self, counter, userId):
3455 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3456 
    args = registerCounter_args()
3457 
    args.counter = counter
3458 
    args.userId = userId
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_registerCounter(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = registerCounter_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
3473 
    if result.success is not None:
3474 
      return result.success
3475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3476 
 
12722 amit.gupta 3477 
  def searchCounter(self, type1, searchString):
3478 
    """
3479 
    Parameters:
3480 
     - type1
3481 
     - searchString
3482 
    """
3483 
    self.send_searchCounter(type1, searchString)
3484 
    return self.recv_searchCounter()
12696 amit.gupta 3485 
 
12722 amit.gupta 3486 
  def send_searchCounter(self, type1, searchString):
3487 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3488 
    args = searchCounter_args()
3489 
    args.type1 = type1
3490 
    args.searchString = searchString
3491 
    args.write(self._oprot)
3492 
    self._oprot.writeMessageEnd()
3493 
    self._oprot.trans.flush()
3494 
 
3495 
  def recv_searchCounter(self, ):
3496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3497 
    if mtype == TMessageType.EXCEPTION:
3498 
      x = TApplicationException()
3499 
      x.read(self._iprot)
3500 
      self._iprot.readMessageEnd()
3501 
      raise x
3502 
    result = searchCounter_result()
3503 
    result.read(self._iprot)
3504 
    self._iprot.readMessageEnd()
3505 
    if result.success is not None:
3506 
      return result.success
3507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3508 
 
18977 amit.gupta 3509 
  def getCounterByUserId(self, userId):
3510 
    """
3511 
    Parameters:
3512 
     - userId
3513 
    """
3514 
    self.send_getCounterByUserId(userId)
3515 
    return self.recv_getCounterByUserId()
3516 
 
3517 
  def send_getCounterByUserId(self, userId):
3518 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3519 
    args = getCounterByUserId_args()
3520 
    args.userId = userId
3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_getCounterByUserId(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = getCounterByUserId_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.success is not None:
3536 
      return result.success
3537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3538 
 
12722 amit.gupta 3539 
  def getAllUsersByCounter(self, counterId):
3540 
    """
3541 
    Parameters:
3542 
     - counterId
3543 
    """
3544 
    self.send_getAllUsersByCounter(counterId)
3545 
    return self.recv_getAllUsersByCounter()
3546 
 
3547 
  def send_getAllUsersByCounter(self, counterId):
3548 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3549 
    args = getAllUsersByCounter_args()
3550 
    args.counterId = counterId
3551 
    args.write(self._oprot)
3552 
    self._oprot.writeMessageEnd()
3553 
    self._oprot.trans.flush()
3554 
 
3555 
  def recv_getAllUsersByCounter(self, ):
3556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3557 
    if mtype == TMessageType.EXCEPTION:
3558 
      x = TApplicationException()
3559 
      x.read(self._iprot)
3560 
      self._iprot.readMessageEnd()
3561 
      raise x
3562 
    result = getAllUsersByCounter_result()
3563 
    result.read(self._iprot)
3564 
    self._iprot.readMessageEnd()
3565 
    if result.success is not None:
3566 
      return result.success
3567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3568 
 
15251 manish.sha 3569 
  def getActiveAccessTokenForUser(self, userId, source):
3570 
    """
3571 
    Parameters:
3572 
     - userId
3573 
     - source
3574 
    """
3575 
    self.send_getActiveAccessTokenForUser(userId, source)
3576 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3577 
 
15251 manish.sha 3578 
  def send_getActiveAccessTokenForUser(self, userId, source):
3579 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3580 
    args = getActiveAccessTokenForUser_args()
3581 
    args.userId = userId
3582 
    args.source = source
3583 
    args.write(self._oprot)
3584 
    self._oprot.writeMessageEnd()
3585 
    self._oprot.trans.flush()
3586 
 
3587 
  def recv_getActiveAccessTokenForUser(self, ):
3588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3589 
    if mtype == TMessageType.EXCEPTION:
3590 
      x = TApplicationException()
3591 
      x.read(self._iprot)
3592 
      self._iprot.readMessageEnd()
3593 
      raise x
3594 
    result = getActiveAccessTokenForUser_result()
3595 
    result.read(self._iprot)
3596 
    self._iprot.readMessageEnd()
3597 
    if result.success is not None:
3598 
      return result.success
3599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3600 
 
3601 
  def validateAccessToken(self, accessToken):
3602 
    """
3603 
    Parameters:
3604 
     - accessToken
3605 
    """
3606 
    self.send_validateAccessToken(accessToken)
3607 
    return self.recv_validateAccessToken()
3608 
 
3609 
  def send_validateAccessToken(self, accessToken):
3610 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3611 
    args = validateAccessToken_args()
3612 
    args.accessToken = accessToken
3613 
    args.write(self._oprot)
3614 
    self._oprot.writeMessageEnd()
3615 
    self._oprot.trans.flush()
3616 
 
3617 
  def recv_validateAccessToken(self, ):
3618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3619 
    if mtype == TMessageType.EXCEPTION:
3620 
      x = TApplicationException()
3621 
      x.read(self._iprot)
3622 
      self._iprot.readMessageEnd()
3623 
      raise x
3624 
    result = validateAccessToken_result()
3625 
    result.read(self._iprot)
3626 
    self._iprot.readMessageEnd()
3627 
    if result.success is not None:
3628 
      return result.success
3629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3630 
 
17782 amit.gupta 3631 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3632 
    """
3633 
    Parameters:
3634 
     - cartId
3635 
     - itemQty
3636 
     - couponCode
3637 
    """
3638 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3639 
    return self.recv_addItemsToCart()
15251 manish.sha 3640 
 
17782 amit.gupta 3641 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3642 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3643 
    args = addItemsToCart_args()
3644 
    args.cartId = cartId
3645 
    args.itemQty = itemQty
3646 
    args.couponCode = couponCode
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_addItemsToCart(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = addItemsToCart_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
3661 
    if result.success is not None:
3662 
      return result.success
3663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3664 
 
3665 
  def validateCartNew(self, cartId, pinCode, sourceId):
3666 
    """
3667 
    Parameters:
3668 
     - cartId
3669 
     - pinCode
3670 
     - sourceId
3671 
    """
3672 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3673 
    return self.recv_validateCartNew()
3674 
 
3675 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3676 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3677 
    args = validateCartNew_args()
3678 
    args.cartId = cartId
3679 
    args.pinCode = pinCode
3680 
    args.sourceId = sourceId
3681 
    args.write(self._oprot)
3682 
    self._oprot.writeMessageEnd()
3683 
    self._oprot.trans.flush()
3684 
 
3685 
  def recv_validateCartNew(self, ):
3686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3687 
    if mtype == TMessageType.EXCEPTION:
3688 
      x = TApplicationException()
3689 
      x.read(self._iprot)
3690 
      self._iprot.readMessageEnd()
3691 
      raise x
3692 
    result = validateCartNew_result()
3693 
    result.read(self._iprot)
3694 
    self._iprot.readMessageEnd()
3695 
    if result.success is not None:
3696 
      return result.success
3697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3698 
 
18644 manish.sha 3699 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3700 
    """
3701 
    Parameters:
3702 
     - userId
3703 
    """
18644 manish.sha 3704 
    self.send_isAddressEditableForCounter(userId)
3705 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3706 
 
18644 manish.sha 3707 
  def send_isAddressEditableForCounter(self, userId):
3708 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3709 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3710 
    args.userId = userId
3711 
    args.write(self._oprot)
3712 
    self._oprot.writeMessageEnd()
3713 
    self._oprot.trans.flush()
3714 
 
18644 manish.sha 3715 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3717 
    if mtype == TMessageType.EXCEPTION:
3718 
      x = TApplicationException()
3719 
      x.read(self._iprot)
3720 
      self._iprot.readMessageEnd()
3721 
      raise x
18644 manish.sha 3722 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3723 
    result.read(self._iprot)
3724 
    self._iprot.readMessageEnd()
3725 
    if result.success is not None:
3726 
      return result.success
18644 manish.sha 3727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3728 
 
3729 
  def getBillingAddressForUser(self, userId):
3730 
    """
3731 
    Parameters:
3732 
     - userId
3733 
    """
3734 
    self.send_getBillingAddressForUser(userId)
3735 
    return self.recv_getBillingAddressForUser()
3736 
 
3737 
  def send_getBillingAddressForUser(self, userId):
3738 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3739 
    args = getBillingAddressForUser_args()
3740 
    args.userId = userId
3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
3745 
  def recv_getBillingAddressForUser(self, ):
3746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3747 
    if mtype == TMessageType.EXCEPTION:
3748 
      x = TApplicationException()
3749 
      x.read(self._iprot)
3750 
      self._iprot.readMessageEnd()
3751 
      raise x
3752 
    result = getBillingAddressForUser_result()
3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
3755 
    if result.success is not None:
3756 
      return result.success
3757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3758 
 
18590 manish.sha 3759 
  def isCreditorAssigned(self, userId):
3760 
    """
3761 
    Parameters:
3762 
     - userId
3763 
    """
3764 
    self.send_isCreditorAssigned(userId)
3765 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3766 
 
18590 manish.sha 3767 
  def send_isCreditorAssigned(self, userId):
3768 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3769 
    args = isCreditorAssigned_args()
3770 
    args.userId = userId
3771 
    args.write(self._oprot)
3772 
    self._oprot.writeMessageEnd()
3773 
    self._oprot.trans.flush()
3774 
 
3775 
  def recv_isCreditorAssigned(self, ):
3776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3777 
    if mtype == TMessageType.EXCEPTION:
3778 
      x = TApplicationException()
3779 
      x.read(self._iprot)
3780 
      self._iprot.readMessageEnd()
3781 
      raise x
3782 
    result = isCreditorAssigned_result()
3783 
    result.read(self._iprot)
3784 
    self._iprot.readMessageEnd()
3785 
    if result.success is not None:
3786 
      return result.success
3787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3788 
 
18735 manish.sha 3789 
  def isTaxInvoiceEnabledUser(self, userId):
3790 
    """
3791 
    Parameters:
3792 
     - userId
3793 
    """
3794 
    self.send_isTaxInvoiceEnabledUser(userId)
3795 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3796 
 
18735 manish.sha 3797 
  def send_isTaxInvoiceEnabledUser(self, userId):
3798 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3799 
    args = isTaxInvoiceEnabledUser_args()
3800 
    args.userId = userId
3801 
    args.write(self._oprot)
3802 
    self._oprot.writeMessageEnd()
3803 
    self._oprot.trans.flush()
3804 
 
3805 
  def recv_isTaxInvoiceEnabledUser(self, ):
3806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3807 
    if mtype == TMessageType.EXCEPTION:
3808 
      x = TApplicationException()
3809 
      x.read(self._iprot)
3810 
      self._iprot.readMessageEnd()
3811 
      raise x
3812 
    result = isTaxInvoiceEnabledUser_result()
3813 
    result.read(self._iprot)
3814 
    self._iprot.readMessageEnd()
3815 
    if result.success is not None:
3816 
      return result.success
3817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3818 
 
19182 amit.gupta 3819 
  def taxInvoiceAvailable(self, addressId):
3820 
    """
3821 
    Parameters:
3822 
     - addressId
3823 
    """
3824 
    self.send_taxInvoiceAvailable(addressId)
3825 
    return self.recv_taxInvoiceAvailable()
3826 
 
3827 
  def send_taxInvoiceAvailable(self, addressId):
3828 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3829 
    args = taxInvoiceAvailable_args()
3830 
    args.addressId = addressId
3831 
    args.write(self._oprot)
3832 
    self._oprot.writeMessageEnd()
3833 
    self._oprot.trans.flush()
3834 
 
3835 
  def recv_taxInvoiceAvailable(self, ):
3836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3837 
    if mtype == TMessageType.EXCEPTION:
3838 
      x = TApplicationException()
3839 
      x.read(self._iprot)
3840 
      self._iprot.readMessageEnd()
3841 
      raise x
3842 
    result = taxInvoiceAvailable_result()
3843 
    result.read(self._iprot)
3844 
    self._iprot.readMessageEnd()
3845 
    if result.success is not None:
3846 
      return result.success
3847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3848 
 
18764 kshitij.so 3849 
  def getCartByValue(self, cartIds):
3850 
    """
3851 
    Parameters:
3852 
     - cartIds
3853 
    """
3854 
    self.send_getCartByValue(cartIds)
3855 
    return self.recv_getCartByValue()
18735 manish.sha 3856 
 
18764 kshitij.so 3857 
  def send_getCartByValue(self, cartIds):
3858 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3859 
    args = getCartByValue_args()
3860 
    args.cartIds = cartIds
3861 
    args.write(self._oprot)
3862 
    self._oprot.writeMessageEnd()
3863 
    self._oprot.trans.flush()
3864 
 
3865 
  def recv_getCartByValue(self, ):
3866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3867 
    if mtype == TMessageType.EXCEPTION:
3868 
      x = TApplicationException()
3869 
      x.read(self._iprot)
3870 
      self._iprot.readMessageEnd()
3871 
      raise x
3872 
    result = getCartByValue_result()
3873 
    result.read(self._iprot)
3874 
    self._iprot.readMessageEnd()
3875 
    if result.success is not None:
3876 
      return result.success
3877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3878 
 
19889 manas 3879 
  def getCounterName(self, userIds):
3880 
    """
3881 
    Parameters:
3882 
     - userIds
3883 
    """
3884 
    self.send_getCounterName(userIds)
3885 
    return self.recv_getCounterName()
18764 kshitij.so 3886 
 
19889 manas 3887 
  def send_getCounterName(self, userIds):
3888 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3889 
    args = getCounterName_args()
3890 
    args.userIds = userIds
3891 
    args.write(self._oprot)
3892 
    self._oprot.writeMessageEnd()
3893 
    self._oprot.trans.flush()
3894 
 
3895 
  def recv_getCounterName(self, ):
3896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3897 
    if mtype == TMessageType.EXCEPTION:
3898 
      x = TApplicationException()
3899 
      x.read(self._iprot)
3900 
      self._iprot.readMessageEnd()
3901 
      raise x
3902 
    result = getCounterName_result()
3903 
    result.read(self._iprot)
3904 
    self._iprot.readMessageEnd()
3905 
    if result.success is not None:
3906 
      return result.success
3907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3908 
 
20873 kshitij.so 3909 
  def setWalletAmountInCart(self, cartId, wallet_amount):
3910 
    """
3911 
    Parameters:
3912 
     - cartId
3913 
     - wallet_amount
3914 
    """
3915 
    self.send_setWalletAmountInCart(cartId, wallet_amount)
3916 
    return self.recv_setWalletAmountInCart()
19889 manas 3917 
 
20873 kshitij.so 3918 
  def send_setWalletAmountInCart(self, cartId, wallet_amount):
3919 
    self._oprot.writeMessageBegin('setWalletAmountInCart', TMessageType.CALL, self._seqid)
3920 
    args = setWalletAmountInCart_args()
3921 
    args.cartId = cartId
3922 
    args.wallet_amount = wallet_amount
3923 
    args.write(self._oprot)
3924 
    self._oprot.writeMessageEnd()
3925 
    self._oprot.trans.flush()
3926 
 
3927 
  def recv_setWalletAmountInCart(self, ):
3928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3929 
    if mtype == TMessageType.EXCEPTION:
3930 
      x = TApplicationException()
3931 
      x.read(self._iprot)
3932 
      self._iprot.readMessageEnd()
3933 
      raise x
3934 
    result = setWalletAmountInCart_result()
3935 
    result.read(self._iprot)
3936 
    self._iprot.readMessageEnd()
3937 
    if result.success is not None:
3938 
      return result.success
3939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setWalletAmountInCart failed: unknown result");
3940 
 
3941 
 
3376 rajveer 3942 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3943 
  def __init__(self, handler):
3376 rajveer 3944 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3945 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3946 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3947 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3948 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3949 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3950 
    self._processMap["createUser"] = Processor.process_createUser
3951 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3952 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3953 
    self._processMap["userExists"] = Processor.process_userExists
3954 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3955 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3956 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3957 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3958 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3959 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3960 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3961 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3962 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3963 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3964 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3965 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3966 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3967 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3968 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3969 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3970 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3971 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3972 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3973 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3974 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3975 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3976 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3977 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3978 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3979 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3980 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3981 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3982 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3983 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3984 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3985 
    self._processMap["getCart"] = Processor.process_getCart
3986 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3987 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3988 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3989 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3990 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3991 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3992 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3993 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3994 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3995 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3996 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3997 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3998 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3999 
    self._processMap["checkOut"] = Processor.process_checkOut
4000 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 4001 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 4002 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 4003 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
4004 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
4005 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
4006 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
4007 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 4008 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 4009 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 4010 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 4011 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 4012 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 4013 
    self._processMap["insureItem"] = Processor.process_insureItem
4014 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
4015 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
4016 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 4017 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 4018 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 4019 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 4020 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
4021 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
4022 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 4023 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 4024 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 4025 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 4026 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 4027 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
4028 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 4029 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
4030 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 4031 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 4032 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 4033 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 4034 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 4035 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 4036 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 4037 
    self._processMap["getCounterName"] = Processor.process_getCounterName
20873 kshitij.so 4038 
    self._processMap["setWalletAmountInCart"] = Processor.process_setWalletAmountInCart
94 ashish 4039 
 
4040 
  def process(self, iprot, oprot):
4041 
    (name, type, seqid) = iprot.readMessageBegin()
4042 
    if name not in self._processMap:
4043 
      iprot.skip(TType.STRUCT)
4044 
      iprot.readMessageEnd()
4045 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4046 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4047 
      x.write(oprot)
4048 
      oprot.writeMessageEnd()
4049 
      oprot.trans.flush()
4050 
      return
4051 
    else:
4052 
      self._processMap[name](self, seqid, iprot, oprot)
4053 
    return True
4054 
 
559 chandransh 4055 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4056 
    args = createAnonymousUser_args()
94 ashish 4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
559 chandransh 4059 
    result = createAnonymousUser_result()
94 ashish 4060 
    try:
559 chandransh 4061 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4062 
    except UserContextException, ucex:
4063 
      result.ucex = ucex
4064 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
559 chandransh 4069 
  def process_getUserById(self, seqid, iprot, oprot):
4070 
    args = getUserById_args()
94 ashish 4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
559 chandransh 4073 
    result = getUserById_result()
94 ashish 4074 
    try:
559 chandransh 4075 
      result.success = self._handler.getUserById(args.userId)
4076 
    except UserContextException, ucex:
4077 
      result.ucex = ucex
4078 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
5326 rajveer 4083 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4084 
    args = getUserByCartId_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getUserByCartId_result()
4088 
    try:
4089 
      result.success = self._handler.getUserByCartId(args.cartId)
4090 
    except UserContextException, ucex:
4091 
      result.ucex = ucex
4092 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
1491 vikas 4097 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4098 
    args = getUserByEmail_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = getUserByEmail_result()
4102 
    try:
4103 
      result.success = self._handler.getUserByEmail(args.email)
4104 
    except UserContextException, ucex:
4105 
      result.ucex = ucex
4106 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
3032 mandeep.dh 4111 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4112 
    args = getUserByMobileNumber_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getUserByMobileNumber_result()
4116 
    try:
4117 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4118 
    except UserContextException, ucex:
4119 
      result.ucex = ucex
4120 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4121 
    result.write(oprot)
4122 
    oprot.writeMessageEnd()
4123 
    oprot.trans.flush()
4124 
 
559 chandransh 4125 
  def process_createUser(self, seqid, iprot, oprot):
4126 
    args = createUser_args()
94 ashish 4127 
    args.read(iprot)
4128 
    iprot.readMessageEnd()
559 chandransh 4129 
    result = createUser_result()
94 ashish 4130 
    try:
559 chandransh 4131 
      result.success = self._handler.createUser(args.user)
4132 
    except UserContextException, ucex:
4133 
      result.ucex = ucex
4134 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4135 
    result.write(oprot)
4136 
    oprot.writeMessageEnd()
4137 
    oprot.trans.flush()
4138 
 
559 chandransh 4139 
  def process_updateUser(self, seqid, iprot, oprot):
4140 
    args = updateUser_args()
94 ashish 4141 
    args.read(iprot)
4142 
    iprot.readMessageEnd()
559 chandransh 4143 
    result = updateUser_result()
94 ashish 4144 
    try:
559 chandransh 4145 
      result.success = self._handler.updateUser(args.user)
4146 
    except UserContextException, ucex:
4147 
      result.ucex = ucex
4148 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4149 
    result.write(oprot)
4150 
    oprot.writeMessageEnd()
4151 
    oprot.trans.flush()
4152 
 
122 ashish 4153 
  def process_authenticateUser(self, seqid, iprot, oprot):
4154 
    args = authenticateUser_args()
4155 
    args.read(iprot)
4156 
    iprot.readMessageEnd()
4157 
    result = authenticateUser_result()
4158 
    try:
559 chandransh 4159 
      result.success = self._handler.authenticateUser(args.email, args.password)
4160 
    except AuthenticationException, auex:
4161 
      result.auex = auex
122 ashish 4162 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4163 
    result.write(oprot)
4164 
    oprot.writeMessageEnd()
4165 
    oprot.trans.flush()
4166 
 
94 ashish 4167 
  def process_userExists(self, seqid, iprot, oprot):
4168 
    args = userExists_args()
4169 
    args.read(iprot)
4170 
    iprot.readMessageEnd()
4171 
    result = userExists_result()
4172 
    try:
4173 
      result.success = self._handler.userExists(args.email)
4174 
    except UserContextException, ucx:
4175 
      result.ucx = ucx
4176 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
4181 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4182 
    args = addAddressForUser_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = addAddressForUser_result()
4186 
    try:
567 rajveer 4187 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4188 
    except UserContextException, ucx:
4189 
      result.ucx = ucx
4190 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
4194 
 
4195 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4196 
    args = removeAddressForUser_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = removeAddressForUser_result()
4200 
    try:
4201 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4202 
    except UserContextException, ucx:
4203 
      result.ucx = ucx
4204 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4205 
    result.write(oprot)
4206 
    oprot.writeMessageEnd()
4207 
    oprot.trans.flush()
4208 
 
4209 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4210 
    args = setUserAsLoggedIn_args()
4211 
    args.read(iprot)
4212 
    iprot.readMessageEnd()
4213 
    result = setUserAsLoggedIn_result()
4214 
    try:
4215 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4216 
    except UserContextException, ucx:
4217 
      result.ucx = ucx
4218 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
4223 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4224 
    args = setUserAsLoggedOut_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = setUserAsLoggedOut_result()
4228 
    try:
4229 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4230 
    except UserContextException, ucx:
4231 
      result.ucx = ucx
4232 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
4236 
 
504 rajveer 4237 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4238 
    args = setDefaultAddress_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = setDefaultAddress_result()
4242 
    try:
4243 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4244 
    except UserContextException, ucx:
4245 
      result.ucx = ucx
4246 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4247 
    result.write(oprot)
4248 
    oprot.writeMessageEnd()
4249 
    oprot.trans.flush()
4250 
 
94 ashish 4251 
  def process_updatePassword(self, seqid, iprot, oprot):
4252 
    args = updatePassword_args()
4253 
    args.read(iprot)
4254 
    iprot.readMessageEnd()
4255 
    result = updatePassword_result()
4256 
    try:
594 rajveer 4257 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4258 
    except UserContextException, ucx:
4259 
      result.ucx = ucx
4260 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
4264 
 
581 rajveer 4265 
  def process_forgotPassword(self, seqid, iprot, oprot):
4266 
    args = forgotPassword_args()
4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
4269 
    result = forgotPassword_result()
4270 
    try:
884 rajveer 4271 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4272 
    except UserContextException, ucx:
4273 
      result.ucx = ucx
4274 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
4278 
 
594 rajveer 4279 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4280 
    args = getAllAddressesForUser_args()
4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
4283 
    result = getAllAddressesForUser_result()
4284 
    try:
4285 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4286 
    except UserContextException, ucx:
4287 
      result.ucx = ucx
4288 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4289 
    result.write(oprot)
4290 
    oprot.writeMessageEnd()
4291 
    oprot.trans.flush()
4292 
 
1894 vikas 4293 
  def process_getAddressById(self, seqid, iprot, oprot):
4294 
    args = getAddressById_args()
4295 
    args.read(iprot)
4296 
    iprot.readMessageEnd()
4297 
    result = getAddressById_result()
4298 
    try:
4299 
      result.success = self._handler.getAddressById(args.addressId)
4300 
    except UserContextException, ucx:
4301 
      result.ucx = ucx
4302 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4303 
    result.write(oprot)
4304 
    oprot.writeMessageEnd()
4305 
    oprot.trans.flush()
4306 
 
594 rajveer 4307 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4308 
    args = getDefaultAddressId_args()
4309 
    args.read(iprot)
4310 
    iprot.readMessageEnd()
4311 
    result = getDefaultAddressId_result()
4312 
    try:
4313 
      result.success = self._handler.getDefaultAddressId(args.userId)
4314 
    except UserContextException, ucx:
4315 
      result.ucx = ucx
4316 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4317 
    result.write(oprot)
4318 
    oprot.writeMessageEnd()
4319 
    oprot.trans.flush()
4320 
 
785 rajveer 4321 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4322 
    args = getDefaultPincode_args()
4323 
    args.read(iprot)
4324 
    iprot.readMessageEnd()
4325 
    result = getDefaultPincode_result()
4326 
    try:
4327 
      result.success = self._handler.getDefaultPincode(args.userId)
4328 
    except UserContextException, ucx:
4329 
      result.ucx = ucx
4330 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4331 
    result.write(oprot)
4332 
    oprot.writeMessageEnd()
4333 
    oprot.trans.flush()
4334 
 
1274 varun.gupt 4335 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4336 
    args = saveUserCommunication_args()
4337 
    args.read(iprot)
4338 
    iprot.readMessageEnd()
4339 
    result = saveUserCommunication_result()
4340 
    try:
4341 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4342 
    except UserCommunicationException, ucx:
4343 
      result.ucx = ucx
4344 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4345 
    result.write(oprot)
4346 
    oprot.writeMessageEnd()
4347 
    oprot.trans.flush()
4348 
 
1590 varun.gupt 4349 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4350 
    args = getUserCommunicationById_args()
4351 
    args.read(iprot)
4352 
    iprot.readMessageEnd()
4353 
    result = getUserCommunicationById_result()
4354 
    try:
4355 
      result.success = self._handler.getUserCommunicationById(args.id)
4356 
    except UserCommunicationException, ucx:
4357 
      result.ucx = ucx
4358 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4359 
    result.write(oprot)
4360 
    oprot.writeMessageEnd()
4361 
    oprot.trans.flush()
4362 
 
4363 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4364 
    args = getUserCommunicationByUser_args()
4365 
    args.read(iprot)
4366 
    iprot.readMessageEnd()
4367 
    result = getUserCommunicationByUser_result()
4368 
    try:
4369 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4370 
    except UserCommunicationException, ucx:
4371 
      result.ucx = ucx
4372 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4373 
    result.write(oprot)
4374 
    oprot.writeMessageEnd()
4375 
    oprot.trans.flush()
4376 
 
4377 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4378 
    args = getAllUserCommunications_args()
4379 
    args.read(iprot)
4380 
    iprot.readMessageEnd()
4381 
    result = getAllUserCommunications_result()
4382 
    try:
4383 
      result.success = self._handler.getAllUserCommunications()
4384 
    except UserCommunicationException, ucx:
4385 
      result.ucx = ucx
4386 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4387 
    result.write(oprot)
4388 
    oprot.writeMessageEnd()
4389 
    oprot.trans.flush()
4390 
 
5407 amar.kumar 4391 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4392 
    args = removeUserCommunication_args()
4393 
    args.read(iprot)
4394 
    iprot.readMessageEnd()
4395 
    result = removeUserCommunication_result()
4396 
    try:
4397 
      self._handler.removeUserCommunication(args.id)
4398 
    except UserCommunicationException, ucx:
4399 
      result.ucx = ucx
4400 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4401 
    result.write(oprot)
4402 
    oprot.writeMessageEnd()
4403 
    oprot.trans.flush()
4404 
 
1845 vikas 4405 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4406 
    args = createMasterAffiliate_args()
4407 
    args.read(iprot)
4408 
    iprot.readMessageEnd()
4409 
    result = createMasterAffiliate_result()
4410 
    try:
1859 vikas 4411 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4412 
    except UserAffiliateException, utx:
1845 vikas 4413 
      result.utx = utx
4414 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4415 
    result.write(oprot)
4416 
    oprot.writeMessageEnd()
4417 
    oprot.trans.flush()
4418 
 
1899 vikas 4419 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4420 
    args = getAllMasterAffiliates_args()
4421 
    args.read(iprot)
4422 
    iprot.readMessageEnd()
4423 
    result = getAllMasterAffiliates_result()
4424 
    try:
4425 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4426 
    except UserAffiliateException, utx:
1899 vikas 4427 
      result.utx = utx
4428 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
1845 vikas 4433 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4434 
    args = getMasterAffiliateById_args()
4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
4437 
    result = getMasterAffiliateById_result()
4438 
    try:
4439 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4440 
    except UserAffiliateException, utx:
1845 vikas 4441 
      result.utx = utx
4442 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4443 
    result.write(oprot)
4444 
    oprot.writeMessageEnd()
4445 
    oprot.trans.flush()
4446 
 
4447 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4448 
    args = getMasterAffiliateByName_args()
4449 
    args.read(iprot)
4450 
    iprot.readMessageEnd()
4451 
    result = getMasterAffiliateByName_result()
4452 
    try:
4453 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4454 
    except UserAffiliateException, utx:
1845 vikas 4455 
      result.utx = utx
4456 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
4461 
  def process_createAffiliate(self, seqid, iprot, oprot):
4462 
    args = createAffiliate_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = createAffiliate_result()
4466 
    try:
1859 vikas 4467 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4468 
    except UserAffiliateException, utx:
1845 vikas 4469 
      result.utx = utx
4470 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4471 
    result.write(oprot)
4472 
    oprot.writeMessageEnd()
4473 
    oprot.trans.flush()
4474 
 
4475 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4476 
    args = getAffiliateById_args()
4477 
    args.read(iprot)
4478 
    iprot.readMessageEnd()
4479 
    result = getAffiliateById_result()
4480 
    try:
4481 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4482 
    except UserAffiliateException, utx:
1845 vikas 4483 
      result.utx = utx
4484 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4485 
    result.write(oprot)
4486 
    oprot.writeMessageEnd()
4487 
    oprot.trans.flush()
4488 
 
4489 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4490 
    args = getAffiliateByName_args()
4491 
    args.read(iprot)
4492 
    iprot.readMessageEnd()
4493 
    result = getAffiliateByName_result()
4494 
    try:
4495 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4496 
    except UserAffiliateException, utx:
1845 vikas 4497 
      result.utx = utx
4498 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4499 
    result.write(oprot)
4500 
    oprot.writeMessageEnd()
4501 
    oprot.trans.flush()
4502 
 
4503 
  def process_getTrackerById(self, seqid, iprot, oprot):
4504 
    args = getTrackerById_args()
4505 
    args.read(iprot)
4506 
    iprot.readMessageEnd()
4507 
    result = getTrackerById_result()
4508 
    try:
1996 vikas 4509 
      result.success = self._handler.getTrackerById(args.id)
4510 
    except UserAffiliateException, utx:
1845 vikas 4511 
      result.utx = utx
4512 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4513 
    result.write(oprot)
4514 
    oprot.writeMessageEnd()
4515 
    oprot.trans.flush()
4516 
 
1996 vikas 4517 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4518 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4519 
    args.read(iprot)
4520 
    iprot.readMessageEnd()
1996 vikas 4521 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4522 
    try:
1996 vikas 4523 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4524 
    except UserAffiliateException, utx:
1845 vikas 4525 
      result.utx = utx
1996 vikas 4526 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
4531 
  def process_addTrackLog(self, seqid, iprot, oprot):
4532 
    args = addTrackLog_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = addTrackLog_result()
4536 
    try:
1996 vikas 4537 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4538 
    except UserAffiliateException, utx:
1845 vikas 4539 
      result.utx = utx
4540 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4541 
    result.write(oprot)
4542 
    oprot.writeMessageEnd()
4543 
    oprot.trans.flush()
4544 
 
4545 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4546 
    args = getTrackLogById_args()
4547 
    args.read(iprot)
4548 
    iprot.readMessageEnd()
4549 
    result = getTrackLogById_result()
4550 
    try:
4551 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4552 
    except UserAffiliateException, utx:
1845 vikas 4553 
      result.utx = utx
4554 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4555 
    result.write(oprot)
4556 
    oprot.writeMessageEnd()
4557 
    oprot.trans.flush()
4558 
 
1996 vikas 4559 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4560 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4561 
    args.read(iprot)
4562 
    iprot.readMessageEnd()
1996 vikas 4563 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4564 
    try:
3293 vikas 4565 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4566 
    except UserAffiliateException, utx:
1845 vikas 4567 
      result.utx = utx
1996 vikas 4568 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
4573 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4574 
    args = getTrackLogsByUser_args()
4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
4577 
    result = getTrackLogsByUser_result()
4578 
    try:
4579 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4580 
    except UserAffiliateException, utx:
1845 vikas 4581 
      result.utx = utx
4582 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
4587 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4588 
    args = getTrackLogs_args()
4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
4591 
    result = getTrackLogs_result()
4592 
    try:
1996 vikas 4593 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4594 
    except UserAffiliateException, utx:
1845 vikas 4595 
      result.utx = utx
4596 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4597 
    result.write(oprot)
4598 
    oprot.writeMessageEnd()
4599 
    oprot.trans.flush()
4600 
 
559 chandransh 4601 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4602 
    args = getCurrentCart_args()
94 ashish 4603 
    args.read(iprot)
4604 
    iprot.readMessageEnd()
559 chandransh 4605 
    result = getCurrentCart_result()
94 ashish 4606 
    try:
559 chandransh 4607 
      result.success = self._handler.getCurrentCart(args.userId)
4608 
    except ShoppingCartException, scx:
4609 
      result.scx = scx
4610 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4611 
    result.write(oprot)
4612 
    oprot.writeMessageEnd()
4613 
    oprot.trans.flush()
4614 
 
559 chandransh 4615 
  def process_getCart(self, seqid, iprot, oprot):
4616 
    args = getCart_args()
94 ashish 4617 
    args.read(iprot)
4618 
    iprot.readMessageEnd()
559 chandransh 4619 
    result = getCart_result()
94 ashish 4620 
    try:
559 chandransh 4621 
      result.success = self._handler.getCart(args.cartId)
4622 
    except ShoppingCartException, scx:
4623 
      result.scx = scx
4624 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4625 
    result.write(oprot)
4626 
    oprot.writeMessageEnd()
4627 
    oprot.trans.flush()
4628 
 
559 chandransh 4629 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4630 
    args = getCartsByTime_args()
94 ashish 4631 
    args.read(iprot)
4632 
    iprot.readMessageEnd()
559 chandransh 4633 
    result = getCartsByTime_result()
94 ashish 4634 
    try:
559 chandransh 4635 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4636 
    except ShoppingCartException, scx:
4637 
      result.scx = scx
4638 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4639 
    result.write(oprot)
4640 
    oprot.writeMessageEnd()
4641 
    oprot.trans.flush()
4642 
 
559 chandransh 4643 
  def process_addItemToCart(self, seqid, iprot, oprot):
4644 
    args = addItemToCart_args()
130 ashish 4645 
    args.read(iprot)
4646 
    iprot.readMessageEnd()
559 chandransh 4647 
    result = addItemToCart_result()
130 ashish 4648 
    try:
3557 rajveer 4649 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4650 
    except ShoppingCartException, scx:
4651 
      result.scx = scx
4652 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4653 
    result.write(oprot)
4654 
    oprot.writeMessageEnd()
4655 
    oprot.trans.flush()
4656 
 
559 chandransh 4657 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4658 
    args = deleteItemFromCart_args()
4659 
    args.read(iprot)
4660 
    iprot.readMessageEnd()
4661 
    result = deleteItemFromCart_result()
4662 
    try:
4663 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4664 
    except ShoppingCartException, scx:
4665 
      result.scx = scx
4666 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4667 
    result.write(oprot)
4668 
    oprot.writeMessageEnd()
4669 
    oprot.trans.flush()
130 ashish 4670 
 
559 chandransh 4671 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4672 
    args = addAddressToCart_args()
4673 
    args.read(iprot)
4674 
    iprot.readMessageEnd()
4675 
    result = addAddressToCart_result()
575 chandransh 4676 
    try:
4677 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4678 
    except ShoppingCartException, scx:
4679 
      result.scx = scx
559 chandransh 4680 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4681 
    result.write(oprot)
4682 
    oprot.writeMessageEnd()
4683 
    oprot.trans.flush()
4684 
 
5553 rajveer 4685 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4686 
    args = addStoreToCart_args()
4687 
    args.read(iprot)
4688 
    iprot.readMessageEnd()
4689 
    result = addStoreToCart_result()
4690 
    try:
4691 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4692 
    except ShoppingCartException, scx:
4693 
      result.scx = scx
4694 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4695 
    result.write(oprot)
4696 
    oprot.writeMessageEnd()
4697 
    oprot.trans.flush()
4698 
 
1976 varun.gupt 4699 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4700 
    args = applyCouponToCart_args()
4701 
    args.read(iprot)
4702 
    iprot.readMessageEnd()
4703 
    result = applyCouponToCart_result()
4704 
    try:
6922 anupam.sin 4705 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4706 
    except ShoppingCartException, scx:
4707 
      result.scx = scx
4708 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4709 
    result.write(oprot)
4710 
    oprot.writeMessageEnd()
4711 
    oprot.trans.flush()
4712 
 
4713 
  def process_removeCoupon(self, seqid, iprot, oprot):
4714 
    args = removeCoupon_args()
4715 
    args.read(iprot)
4716 
    iprot.readMessageEnd()
4717 
    result = removeCoupon_result()
4718 
    try:
4719 
      self._handler.removeCoupon(args.cartId)
4720 
    except ShoppingCartException, scx:
4721 
      result.scx = scx
4722 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4723 
    result.write(oprot)
4724 
    oprot.writeMessageEnd()
4725 
    oprot.trans.flush()
4726 
 
3554 varun.gupt 4727 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4728 
    args = deleteDiscountsFromCart_args()
4729 
    args.read(iprot)
4730 
    iprot.readMessageEnd()
4731 
    result = deleteDiscountsFromCart_result()
4732 
    try:
4733 
      self._handler.deleteDiscountsFromCart(args.cartId)
4734 
    except ShoppingCartException, scx:
4735 
      result.scx = scx
4736 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4737 
    result.write(oprot)
4738 
    oprot.writeMessageEnd()
4739 
    oprot.trans.flush()
4740 
 
4741 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4742 
    args = saveDiscounts_args()
4743 
    args.read(iprot)
4744 
    iprot.readMessageEnd()
4745 
    result = saveDiscounts_result()
4746 
    try:
4747 
      self._handler.saveDiscounts(args.discounts)
4748 
    except ShoppingCartException, scx:
4749 
      result.scx = scx
4750 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4751 
    result.write(oprot)
4752 
    oprot.writeMessageEnd()
4753 
    oprot.trans.flush()
4754 
 
690 chandransh 4755 
  def process_createOrders(self, seqid, iprot, oprot):
4756 
    args = createOrders_args()
559 chandransh 4757 
    args.read(iprot)
4758 
    iprot.readMessageEnd()
690 chandransh 4759 
    result = createOrders_result()
559 chandransh 4760 
    try:
21454 amit.gupta 4761 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource, args.selfPickup)
559 chandransh 4762 
    except ShoppingCartException, scx:
4763 
      result.scx = scx
690 chandransh 4764 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4765 
    result.write(oprot)
4766 
    oprot.writeMessageEnd()
4767 
    oprot.trans.flush()
4768 
 
4769 
  def process_validateCart(self, seqid, iprot, oprot):
4770 
    args = validateCart_args()
4771 
    args.read(iprot)
4772 
    iprot.readMessageEnd()
4773 
    result = validateCart_result()
575 chandransh 4774 
    try:
3557 rajveer 4775 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4776 
    except ShoppingCartException, scex:
4777 
      result.scex = scex
559 chandransh 4778 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4779 
    result.write(oprot)
4780 
    oprot.writeMessageEnd()
4781 
    oprot.trans.flush()
4782 
 
11980 amit.gupta 4783 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4784 
    args = validateCartWithDealerCoupon_args()
4785 
    args.read(iprot)
4786 
    iprot.readMessageEnd()
4787 
    result = validateCartWithDealerCoupon_result()
4788 
    try:
4789 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4790 
    except ShoppingCartException, scex:
4791 
      result.scex = scex
4792 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4793 
    result.write(oprot)
4794 
    oprot.writeMessageEnd()
4795 
    oprot.trans.flush()
4796 
 
690 chandransh 4797 
  def process_mergeCart(self, seqid, iprot, oprot):
4798 
    args = mergeCart_args()
575 chandransh 4799 
    args.read(iprot)
4800 
    iprot.readMessageEnd()
690 chandransh 4801 
    result = mergeCart_result()
4802 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4803 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4804 
    result.write(oprot)
4805 
    oprot.writeMessageEnd()
4806 
    oprot.trans.flush()
4807 
 
4808 
  def process_checkOut(self, seqid, iprot, oprot):
4809 
    args = checkOut_args()
4810 
    args.read(iprot)
4811 
    iprot.readMessageEnd()
4812 
    result = checkOut_result()
575 chandransh 4813 
    try:
690 chandransh 4814 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4815 
    except ShoppingCartException, scex:
4816 
      result.scex = scex
690 chandransh 4817 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4818 
    result.write(oprot)
4819 
    oprot.writeMessageEnd()
4820 
    oprot.trans.flush()
4821 
 
690 chandransh 4822 
  def process_resetCart(self, seqid, iprot, oprot):
4823 
    args = resetCart_args()
559 chandransh 4824 
    args.read(iprot)
4825 
    iprot.readMessageEnd()
690 chandransh 4826 
    result = resetCart_result()
4827 
    try:
4828 
      result.success = self._handler.resetCart(args.cartId, args.items)
4829 
    except ShoppingCartException, scex:
4830 
      result.scex = scex
4831 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4832 
    result.write(oprot)
4833 
    oprot.writeMessageEnd()
4834 
    oprot.trans.flush()
4835 
 
2981 rajveer 4836 
  def process_getUserCount(self, seqid, iprot, oprot):
4837 
    args = getUserCount_args()
559 chandransh 4838 
    args.read(iprot)
4839 
    iprot.readMessageEnd()
2981 rajveer 4840 
    result = getUserCount_result()
4841 
    result.success = self._handler.getUserCount(args.userType)
4842 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4843 
    result.write(oprot)
4844 
    oprot.writeMessageEnd()
4845 
    oprot.trans.flush()
4846 
 
2981 rajveer 4847 
  def process_getAllUsers(self, seqid, iprot, oprot):
4848 
    args = getAllUsers_args()
559 chandransh 4849 
    args.read(iprot)
4850 
    iprot.readMessageEnd()
2981 rajveer 4851 
    result = getAllUsers_result()
4852 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4853 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4854 
    result.write(oprot)
4855 
    oprot.writeMessageEnd()
4856 
    oprot.trans.flush()
4857 
 
2981 rajveer 4858 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4859 
    args = getMyResearchItems_args()
559 chandransh 4860 
    args.read(iprot)
4861 
    iprot.readMessageEnd()
2981 rajveer 4862 
    result = getMyResearchItems_result()
559 chandransh 4863 
    try:
2981 rajveer 4864 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4865 
    except WidgetException, scx:
4866 
      result.scx = scx
2981 rajveer 4867 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
2981 rajveer 4872 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4873 
    args = updateMyResearch_args()
772 rajveer 4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
2981 rajveer 4876 
    result = updateMyResearch_result()
4877 
    try:
4878 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4879 
    except WidgetException, scx:
4880 
      result.scx = scx
4881 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4882 
    result.write(oprot)
4883 
    oprot.writeMessageEnd()
4884 
    oprot.trans.flush()
559 chandransh 4885 
 
2981 rajveer 4886 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4887 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4888 
    args.read(iprot)
4889 
    iprot.readMessageEnd()
2981 rajveer 4890 
    result = deleteItemFromMyResearch_result()
4891 
    try:
4892 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4893 
    except WidgetException, scx:
4894 
      result.scx = scx
4895 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4896 
    result.write(oprot)
4897 
    oprot.writeMessageEnd()
4898 
    oprot.trans.flush()
772 rajveer 4899 
 
2981 rajveer 4900 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4901 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4902 
    args.read(iprot)
4903 
    iprot.readMessageEnd()
2981 rajveer 4904 
    result = getBrowseHistoryItems_result()
4905 
    try:
4906 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4907 
    except WidgetException, scx:
4908 
      result.scx = scx
4909 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4910 
    result.write(oprot)
4911 
    oprot.writeMessageEnd()
4912 
    oprot.trans.flush()
1596 ankur.sing 4913 
 
2981 rajveer 4914 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4915 
    args = updateBrowseHistory_args()
2642 varun.gupt 4916 
    args.read(iprot)
4917 
    iprot.readMessageEnd()
2981 rajveer 4918 
    result = updateBrowseHistory_result()
4919 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4920 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4921 
    result.write(oprot)
4922 
    oprot.writeMessageEnd()
4923 
    oprot.trans.flush()
1673 ankur.sing 4924 
 
3385 varun.gupt 4925 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4926 
    args = getCartsWithCouponCount_args()
4927 
    args.read(iprot)
4928 
    iprot.readMessageEnd()
4929 
    result = getCartsWithCouponCount_result()
4930 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4931 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
2642 varun.gupt 4935 
 
3499 mandeep.dh 4936 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4937 
    args = increaseTrustLevel_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4941 
    return
3385 varun.gupt 4942 
 
5407 amar.kumar 4943 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4944 
    args = getTrustLevel_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = getTrustLevel_result()
4948 
    result.success = self._handler.getTrustLevel(args.userId)
4949 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
4668 varun.gupt 4954 
  def process_showCODOption(self, seqid, iprot, oprot):
4955 
    args = showCODOption_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = showCODOption_result()
4959 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4960 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
3499 mandeep.dh 4964 
 
5623 anupam.sin 4965 
  def process_getUserEmails(self, seqid, iprot, oprot):
4966 
    args = getUserEmails_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = getUserEmails_result()
4970 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4971 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4668 varun.gupt 4975 
 
6903 anupam.sin 4976 
  def process_insureItem(self, seqid, iprot, oprot):
4977 
    args = insureItem_args()
4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
4980 
    result = insureItem_result()
9299 kshitij.so 4981 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4982 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
4986 
 
4987 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4988 
    args = cancelInsurance_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = cancelInsurance_result()
4992 
    result.success = self._handler.cancelInsurance(args.cartId)
4993 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4994 
    result.write(oprot)
4995 
    oprot.writeMessageEnd()
4996 
    oprot.trans.flush()
4997 
 
4998 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4999 
    args = storeInsuranceSpecificDetails_args()
5000 
    args.read(iprot)
5001 
    iprot.readMessageEnd()
5002 
    result = storeInsuranceSpecificDetails_result()
5003 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
5004 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
5005 
    result.write(oprot)
5006 
    oprot.writeMessageEnd()
5007 
    oprot.trans.flush()
5008 
 
5009 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
5010 
    args = isInsuranceDetailPresent_args()
5011 
    args.read(iprot)
5012 
    iprot.readMessageEnd()
5013 
    result = isInsuranceDetailPresent_result()
5014 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
5015 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
5016 
    result.write(oprot)
5017 
    oprot.writeMessageEnd()
5018 
    oprot.trans.flush()
5019 
 
9791 rajveer 5020 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
5021 
    args = getProductsAddedToCart_args()
6821 amar.kumar 5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
9791 rajveer 5024 
    result = getProductsAddedToCart_result()
5025 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
5026 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 5027 
    result.write(oprot)
5028 
    oprot.writeMessageEnd()
5029 
    oprot.trans.flush()
5623 anupam.sin 5030 
 
11592 amit.gupta 5031 
  def process_validateCartPlus(self, seqid, iprot, oprot):
5032 
    args = validateCartPlus_args()
5033 
    args.read(iprot)
5034 
    iprot.readMessageEnd()
5035 
    result = validateCartPlus_result()
5036 
    try:
11980 amit.gupta 5037 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 5038 
    except ShoppingCartException, scex:
5039 
      result.scex = scex
5040 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
5041 
    result.write(oprot)
5042 
    oprot.writeMessageEnd()
5043 
    oprot.trans.flush()
6821 amar.kumar 5044 
 
11679 vikram.rag 5045 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5046 
    args = isPrivateDealUser_args()
5047 
    args.read(iprot)
5048 
    iprot.readMessageEnd()
5049 
    result = isPrivateDealUser_result()
5050 
    result.success = self._handler.isPrivateDealUser(args.userId)
5051 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5052 
    result.write(oprot)
5053 
    oprot.writeMessageEnd()
5054 
    oprot.trans.flush()
11592 amit.gupta 5055 
 
11890 kshitij.so 5056 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5057 
    args = addPrivateDealUser_args()
5058 
    args.read(iprot)
5059 
    iprot.readMessageEnd()
5060 
    result = addPrivateDealUser_result()
5061 
    result.success = self._handler.addPrivateDealUser(args.userId)
5062 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5063 
    result.write(oprot)
5064 
    oprot.writeMessageEnd()
5065 
    oprot.trans.flush()
11679 vikram.rag 5066 
 
11890 kshitij.so 5067 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5068 
    args = changePrivateDealUserStatus_args()
5069 
    args.read(iprot)
5070 
    iprot.readMessageEnd()
5071 
    result = changePrivateDealUserStatus_result()
5072 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5073 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5074 
    result.write(oprot)
5075 
    oprot.writeMessageEnd()
5076 
    oprot.trans.flush()
5077 
 
5078 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5079 
    args = getPrivateDealUser_args()
5080 
    args.read(iprot)
5081 
    iprot.readMessageEnd()
5082 
    result = getPrivateDealUser_result()
5083 
    result.success = self._handler.getPrivateDealUser(args.userId)
5084 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
12696 amit.gupta 5089 
  def process_registerCounter(self, seqid, iprot, oprot):
5090 
    args = registerCounter_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = registerCounter_result()
5094 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5095 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5096 
    result.write(oprot)
5097 
    oprot.writeMessageEnd()
5098 
    oprot.trans.flush()
11890 kshitij.so 5099 
 
12722 amit.gupta 5100 
  def process_searchCounter(self, seqid, iprot, oprot):
5101 
    args = searchCounter_args()
5102 
    args.read(iprot)
5103 
    iprot.readMessageEnd()
5104 
    result = searchCounter_result()
5105 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5106 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5107 
    result.write(oprot)
5108 
    oprot.writeMessageEnd()
5109 
    oprot.trans.flush()
12696 amit.gupta 5110 
 
18977 amit.gupta 5111 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5112 
    args = getCounterByUserId_args()
5113 
    args.read(iprot)
5114 
    iprot.readMessageEnd()
5115 
    result = getCounterByUserId_result()
5116 
    result.success = self._handler.getCounterByUserId(args.userId)
5117 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
5121 
 
12722 amit.gupta 5122 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5123 
    args = getAllUsersByCounter_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = getAllUsersByCounter_result()
5127 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5128 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
15251 manish.sha 5133 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5134 
    args = getActiveAccessTokenForUser_args()
5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
5137 
    result = getActiveAccessTokenForUser_result()
5138 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5139 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
12722 amit.gupta 5143 
 
15251 manish.sha 5144 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5145 
    args = validateAccessToken_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = validateAccessToken_result()
5149 
    result.success = self._handler.validateAccessToken(args.accessToken)
5150 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
5154 
 
17782 amit.gupta 5155 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5156 
    args = addItemsToCart_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = addItemsToCart_result()
5160 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5161 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
15251 manish.sha 5165 
 
17782 amit.gupta 5166 
  def process_validateCartNew(self, seqid, iprot, oprot):
5167 
    args = validateCartNew_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = validateCartNew_result()
5171 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5172 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
5176 
 
18644 manish.sha 5177 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5178 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
18644 manish.sha 5181 
    result = isAddressEditableForCounter_result()
5182 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5183 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5184 
    result.write(oprot)
5185 
    oprot.writeMessageEnd()
5186 
    oprot.trans.flush()
17782 amit.gupta 5187 
 
18530 manish.sha 5188 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5189 
    args = getBillingAddressForUser_args()
5190 
    args.read(iprot)
5191 
    iprot.readMessageEnd()
5192 
    result = getBillingAddressForUser_result()
5193 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5194 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5195 
    result.write(oprot)
5196 
    oprot.writeMessageEnd()
5197 
    oprot.trans.flush()
5198 
 
18590 manish.sha 5199 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5200 
    args = isCreditorAssigned_args()
5201 
    args.read(iprot)
5202 
    iprot.readMessageEnd()
5203 
    result = isCreditorAssigned_result()
5204 
    result.success = self._handler.isCreditorAssigned(args.userId)
5205 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5206 
    result.write(oprot)
5207 
    oprot.writeMessageEnd()
5208 
    oprot.trans.flush()
18530 manish.sha 5209 
 
18735 manish.sha 5210 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5211 
    args = isTaxInvoiceEnabledUser_args()
5212 
    args.read(iprot)
5213 
    iprot.readMessageEnd()
5214 
    result = isTaxInvoiceEnabledUser_result()
5215 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5216 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5217 
    result.write(oprot)
5218 
    oprot.writeMessageEnd()
5219 
    oprot.trans.flush()
18590 manish.sha 5220 
 
19182 amit.gupta 5221 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5222 
    args = taxInvoiceAvailable_args()
5223 
    args.read(iprot)
5224 
    iprot.readMessageEnd()
5225 
    result = taxInvoiceAvailable_result()
5226 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5227 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5228 
    result.write(oprot)
5229 
    oprot.writeMessageEnd()
5230 
    oprot.trans.flush()
5231 
 
18764 kshitij.so 5232 
  def process_getCartByValue(self, seqid, iprot, oprot):
5233 
    args = getCartByValue_args()
5234 
    args.read(iprot)
5235 
    iprot.readMessageEnd()
5236 
    result = getCartByValue_result()
5237 
    result.success = self._handler.getCartByValue(args.cartIds)
5238 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5239 
    result.write(oprot)
5240 
    oprot.writeMessageEnd()
5241 
    oprot.trans.flush()
18735 manish.sha 5242 
 
19889 manas 5243 
  def process_getCounterName(self, seqid, iprot, oprot):
5244 
    args = getCounterName_args()
5245 
    args.read(iprot)
5246 
    iprot.readMessageEnd()
5247 
    result = getCounterName_result()
5248 
    result.success = self._handler.getCounterName(args.userIds)
5249 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5250 
    result.write(oprot)
5251 
    oprot.writeMessageEnd()
5252 
    oprot.trans.flush()
18764 kshitij.so 5253 
 
20873 kshitij.so 5254 
  def process_setWalletAmountInCart(self, seqid, iprot, oprot):
5255 
    args = setWalletAmountInCart_args()
5256 
    args.read(iprot)
5257 
    iprot.readMessageEnd()
5258 
    result = setWalletAmountInCart_result()
5259 
    result.success = self._handler.setWalletAmountInCart(args.cartId, args.wallet_amount)
5260 
    oprot.writeMessageBegin("setWalletAmountInCart", TMessageType.REPLY, seqid)
5261 
    result.write(oprot)
5262 
    oprot.writeMessageEnd()
5263 
    oprot.trans.flush()
19889 manas 5264 
 
20873 kshitij.so 5265 
 
94 ashish 5266 
# HELPER FUNCTIONS AND STRUCTURES
5267 
 
559 chandransh 5268 
class createAnonymousUser_args:
94 ashish 5269 
  """
5270 
  Attributes:
559 chandransh 5271 
   - jsessionId
94 ashish 5272 
  """
5273 
 
5274 
  thrift_spec = (
5275 
    None, # 0
559 chandransh 5276 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5277 
  )
5278 
 
559 chandransh 5279 
  def __init__(self, jsessionId=None,):
5280 
    self.jsessionId = jsessionId
94 ashish 5281 
 
5282 
  def read(self, iprot):
5283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5285 
      return
5286 
    iprot.readStructBegin()
5287 
    while True:
5288 
      (fname, ftype, fid) = iprot.readFieldBegin()
5289 
      if ftype == TType.STOP:
5290 
        break
5291 
      if fid == 1:
559 chandransh 5292 
        if ftype == TType.STRING:
5293 
          self.jsessionId = iprot.readString();
94 ashish 5294 
        else:
5295 
          iprot.skip(ftype)
5296 
      else:
5297 
        iprot.skip(ftype)
5298 
      iprot.readFieldEnd()
5299 
    iprot.readStructEnd()
5300 
 
5301 
  def write(self, oprot):
5302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5304 
      return
559 chandransh 5305 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5306 
    if self.jsessionId is not None:
559 chandransh 5307 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5308 
      oprot.writeString(self.jsessionId)
94 ashish 5309 
      oprot.writeFieldEnd()
5310 
    oprot.writeFieldStop()
5311 
    oprot.writeStructEnd()
5312 
 
3431 rajveer 5313 
  def validate(self):
5314 
    return
5315 
 
5316 
 
94 ashish 5317 
  def __repr__(self):
5318 
    L = ['%s=%r' % (key, value)
5319 
      for key, value in self.__dict__.iteritems()]
5320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5321 
 
5322 
  def __eq__(self, other):
5323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5324 
 
5325 
  def __ne__(self, other):
5326 
    return not (self == other)
5327 
 
559 chandransh 5328 
class createAnonymousUser_result:
94 ashish 5329 
  """
5330 
  Attributes:
5331 
   - success
559 chandransh 5332 
   - ucex
94 ashish 5333 
  """
5334 
 
5335 
  thrift_spec = (
559 chandransh 5336 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5337 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5338 
  )
5339 
 
559 chandransh 5340 
  def __init__(self, success=None, ucex=None,):
94 ashish 5341 
    self.success = success
559 chandransh 5342 
    self.ucex = ucex
94 ashish 5343 
 
5344 
  def read(self, iprot):
5345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5347 
      return
5348 
    iprot.readStructBegin()
5349 
    while True:
5350 
      (fname, ftype, fid) = iprot.readFieldBegin()
5351 
      if ftype == TType.STOP:
5352 
        break
5353 
      if fid == 0:
5354 
        if ftype == TType.STRUCT:
559 chandransh 5355 
          self.success = User()
94 ashish 5356 
          self.success.read(iprot)
5357 
        else:
5358 
          iprot.skip(ftype)
5359 
      elif fid == 1:
5360 
        if ftype == TType.STRUCT:
559 chandransh 5361 
          self.ucex = UserContextException()
5362 
          self.ucex.read(iprot)
94 ashish 5363 
        else:
5364 
          iprot.skip(ftype)
5365 
      else:
5366 
        iprot.skip(ftype)
5367 
      iprot.readFieldEnd()
5368 
    iprot.readStructEnd()
5369 
 
5370 
  def write(self, oprot):
5371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5373 
      return
559 chandransh 5374 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5375 
    if self.success is not None:
94 ashish 5376 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5377 
      self.success.write(oprot)
5378 
      oprot.writeFieldEnd()
3431 rajveer 5379 
    if self.ucex is not None:
559 chandransh 5380 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5381 
      self.ucex.write(oprot)
94 ashish 5382 
      oprot.writeFieldEnd()
5383 
    oprot.writeFieldStop()
5384 
    oprot.writeStructEnd()
5385 
 
3431 rajveer 5386 
  def validate(self):
5387 
    return
5388 
 
5389 
 
94 ashish 5390 
  def __repr__(self):
5391 
    L = ['%s=%r' % (key, value)
5392 
      for key, value in self.__dict__.iteritems()]
5393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5394 
 
5395 
  def __eq__(self, other):
5396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5397 
 
5398 
  def __ne__(self, other):
5399 
    return not (self == other)
5400 
 
559 chandransh 5401 
class getUserById_args:
94 ashish 5402 
  """
5403 
  Attributes:
5404 
   - userId
5405 
  """
5406 
 
5407 
  thrift_spec = (
5408 
    None, # 0
5409 
    (1, TType.I64, 'userId', None, None, ), # 1
5410 
  )
5411 
 
559 chandransh 5412 
  def __init__(self, userId=None,):
94 ashish 5413 
    self.userId = userId
5414 
 
5415 
  def read(self, iprot):
5416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5418 
      return
5419 
    iprot.readStructBegin()
5420 
    while True:
5421 
      (fname, ftype, fid) = iprot.readFieldBegin()
5422 
      if ftype == TType.STOP:
5423 
        break
5424 
      if fid == 1:
5425 
        if ftype == TType.I64:
5426 
          self.userId = iprot.readI64();
5427 
        else:
5428 
          iprot.skip(ftype)
5429 
      else:
5430 
        iprot.skip(ftype)
5431 
      iprot.readFieldEnd()
5432 
    iprot.readStructEnd()
5433 
 
5434 
  def write(self, oprot):
5435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5437 
      return
559 chandransh 5438 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5439 
    if self.userId is not None:
94 ashish 5440 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5441 
      oprot.writeI64(self.userId)
5442 
      oprot.writeFieldEnd()
5443 
    oprot.writeFieldStop()
5444 
    oprot.writeStructEnd()
5445 
 
3431 rajveer 5446 
  def validate(self):
5447 
    return
5448 
 
5449 
 
94 ashish 5450 
  def __repr__(self):
5451 
    L = ['%s=%r' % (key, value)
5452 
      for key, value in self.__dict__.iteritems()]
5453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5454 
 
5455 
  def __eq__(self, other):
5456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5457 
 
5458 
  def __ne__(self, other):
5459 
    return not (self == other)
5460 
 
559 chandransh 5461 
class getUserById_result:
94 ashish 5462 
  """
5463 
  Attributes:
5464 
   - success
559 chandransh 5465 
   - ucex
94 ashish 5466 
  """
5467 
 
5468 
  thrift_spec = (
559 chandransh 5469 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5470 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5471 
  )
5472 
 
559 chandransh 5473 
  def __init__(self, success=None, ucex=None,):
94 ashish 5474 
    self.success = success
559 chandransh 5475 
    self.ucex = ucex
94 ashish 5476 
 
5477 
  def read(self, iprot):
5478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5480 
      return
5481 
    iprot.readStructBegin()
5482 
    while True:
5483 
      (fname, ftype, fid) = iprot.readFieldBegin()
5484 
      if ftype == TType.STOP:
5485 
        break
5486 
      if fid == 0:
5487 
        if ftype == TType.STRUCT:
559 chandransh 5488 
          self.success = User()
94 ashish 5489 
          self.success.read(iprot)
5490 
        else:
5491 
          iprot.skip(ftype)
5492 
      elif fid == 1:
5493 
        if ftype == TType.STRUCT:
559 chandransh 5494 
          self.ucex = UserContextException()
5495 
          self.ucex.read(iprot)
94 ashish 5496 
        else:
5497 
          iprot.skip(ftype)
5498 
      else:
5499 
        iprot.skip(ftype)
5500 
      iprot.readFieldEnd()
5501 
    iprot.readStructEnd()
5502 
 
5503 
  def write(self, oprot):
5504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5506 
      return
559 chandransh 5507 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5508 
    if self.success is not None:
94 ashish 5509 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5510 
      self.success.write(oprot)
5511 
      oprot.writeFieldEnd()
3431 rajveer 5512 
    if self.ucex is not None:
559 chandransh 5513 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5514 
      self.ucex.write(oprot)
94 ashish 5515 
      oprot.writeFieldEnd()
5516 
    oprot.writeFieldStop()
5517 
    oprot.writeStructEnd()
5518 
 
3431 rajveer 5519 
  def validate(self):
5520 
    return
5521 
 
5522 
 
94 ashish 5523 
  def __repr__(self):
5524 
    L = ['%s=%r' % (key, value)
5525 
      for key, value in self.__dict__.iteritems()]
5526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5527 
 
5528 
  def __eq__(self, other):
5529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5530 
 
5531 
  def __ne__(self, other):
5532 
    return not (self == other)
5533 
 
5326 rajveer 5534 
class getUserByCartId_args:
1491 vikas 5535 
  """
5536 
  Attributes:
5326 rajveer 5537 
   - cartId
1491 vikas 5538 
  """
5539 
 
5540 
  thrift_spec = (
5541 
    None, # 0
5326 rajveer 5542 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5543 
  )
5544 
 
5326 rajveer 5545 
  def __init__(self, cartId=None,):
5546 
    self.cartId = cartId
1491 vikas 5547 
 
5548 
  def read(self, iprot):
5549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5551 
      return
5552 
    iprot.readStructBegin()
5553 
    while True:
5554 
      (fname, ftype, fid) = iprot.readFieldBegin()
5555 
      if ftype == TType.STOP:
5556 
        break
5557 
      if fid == 1:
5326 rajveer 5558 
        if ftype == TType.I64:
5559 
          self.cartId = iprot.readI64();
1491 vikas 5560 
        else:
5561 
          iprot.skip(ftype)
5562 
      else:
5563 
        iprot.skip(ftype)
5564 
      iprot.readFieldEnd()
5565 
    iprot.readStructEnd()
5566 
 
5567 
  def write(self, oprot):
5568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5570 
      return
5326 rajveer 5571 
    oprot.writeStructBegin('getUserByCartId_args')
5572 
    if self.cartId is not None:
5573 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5574 
      oprot.writeI64(self.cartId)
1491 vikas 5575 
      oprot.writeFieldEnd()
5576 
    oprot.writeFieldStop()
5577 
    oprot.writeStructEnd()
5578 
 
3431 rajveer 5579 
  def validate(self):
5580 
    return
5581 
 
5582 
 
1491 vikas 5583 
  def __repr__(self):
5584 
    L = ['%s=%r' % (key, value)
5585 
      for key, value in self.__dict__.iteritems()]
5586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5587 
 
5588 
  def __eq__(self, other):
5589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5590 
 
5591 
  def __ne__(self, other):
5592 
    return not (self == other)
5593 
 
5326 rajveer 5594 
class getUserByCartId_result:
1491 vikas 5595 
  """
5596 
  Attributes:
5597 
   - success
5598 
   - ucex
5599 
  """
5600 
 
5601 
  thrift_spec = (
5602 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5603 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5604 
  )
5605 
 
5606 
  def __init__(self, success=None, ucex=None,):
5607 
    self.success = success
5608 
    self.ucex = ucex
5609 
 
5610 
  def read(self, iprot):
5611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5613 
      return
5614 
    iprot.readStructBegin()
5615 
    while True:
5616 
      (fname, ftype, fid) = iprot.readFieldBegin()
5617 
      if ftype == TType.STOP:
5618 
        break
5619 
      if fid == 0:
5620 
        if ftype == TType.STRUCT:
5621 
          self.success = User()
5622 
          self.success.read(iprot)
5623 
        else:
5624 
          iprot.skip(ftype)
5625 
      elif fid == 1:
5626 
        if ftype == TType.STRUCT:
5627 
          self.ucex = UserContextException()
5628 
          self.ucex.read(iprot)
5629 
        else:
5630 
          iprot.skip(ftype)
5631 
      else:
5632 
        iprot.skip(ftype)
5633 
      iprot.readFieldEnd()
5634 
    iprot.readStructEnd()
5635 
 
5636 
  def write(self, oprot):
5637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5639 
      return
5326 rajveer 5640 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5641 
    if self.success is not None:
1491 vikas 5642 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5643 
      self.success.write(oprot)
5644 
      oprot.writeFieldEnd()
3431 rajveer 5645 
    if self.ucex is not None:
1491 vikas 5646 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5647 
      self.ucex.write(oprot)
5648 
      oprot.writeFieldEnd()
5649 
    oprot.writeFieldStop()
5650 
    oprot.writeStructEnd()
5651 
 
3431 rajveer 5652 
  def validate(self):
5653 
    return
5654 
 
5655 
 
1491 vikas 5656 
  def __repr__(self):
5657 
    L = ['%s=%r' % (key, value)
5658 
      for key, value in self.__dict__.iteritems()]
5659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5660 
 
5661 
  def __eq__(self, other):
5662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5663 
 
5664 
  def __ne__(self, other):
5665 
    return not (self == other)
5666 
 
5326 rajveer 5667 
class getUserByEmail_args:
3032 mandeep.dh 5668 
  """
5669 
  Attributes:
5326 rajveer 5670 
   - email
3032 mandeep.dh 5671 
  """
5672 
 
5673 
  thrift_spec = (
5674 
    None, # 0
5326 rajveer 5675 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5676 
  )
5677 
 
5326 rajveer 5678 
  def __init__(self, email=None,):
5679 
    self.email = email
3032 mandeep.dh 5680 
 
5681 
  def read(self, iprot):
5682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5684 
      return
5685 
    iprot.readStructBegin()
5686 
    while True:
5687 
      (fname, ftype, fid) = iprot.readFieldBegin()
5688 
      if ftype == TType.STOP:
5689 
        break
5690 
      if fid == 1:
5326 rajveer 5691 
        if ftype == TType.STRING:
5692 
          self.email = iprot.readString();
3032 mandeep.dh 5693 
        else:
5694 
          iprot.skip(ftype)
5695 
      else:
5696 
        iprot.skip(ftype)
5697 
      iprot.readFieldEnd()
5698 
    iprot.readStructEnd()
5699 
 
5700 
  def write(self, oprot):
5701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5703 
      return
5326 rajveer 5704 
    oprot.writeStructBegin('getUserByEmail_args')
5705 
    if self.email is not None:
5706 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5707 
      oprot.writeString(self.email)
3032 mandeep.dh 5708 
      oprot.writeFieldEnd()
5709 
    oprot.writeFieldStop()
5710 
    oprot.writeStructEnd()
5711 
 
3431 rajveer 5712 
  def validate(self):
5713 
    return
5714 
 
5715 
 
3032 mandeep.dh 5716 
  def __repr__(self):
5717 
    L = ['%s=%r' % (key, value)
5718 
      for key, value in self.__dict__.iteritems()]
5719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5720 
 
5721 
  def __eq__(self, other):
5722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5723 
 
5724 
  def __ne__(self, other):
5725 
    return not (self == other)
5726 
 
5326 rajveer 5727 
class getUserByEmail_result:
3032 mandeep.dh 5728 
  """
5729 
  Attributes:
5730 
   - success
5731 
   - ucex
5732 
  """
5733 
 
5734 
  thrift_spec = (
5735 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5736 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5737 
  )
5738 
 
5739 
  def __init__(self, success=None, ucex=None,):
5740 
    self.success = success
5741 
    self.ucex = ucex
5742 
 
5743 
  def read(self, iprot):
5744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5746 
      return
5747 
    iprot.readStructBegin()
5748 
    while True:
5749 
      (fname, ftype, fid) = iprot.readFieldBegin()
5750 
      if ftype == TType.STOP:
5751 
        break
5752 
      if fid == 0:
5753 
        if ftype == TType.STRUCT:
5754 
          self.success = User()
5755 
          self.success.read(iprot)
5756 
        else:
5757 
          iprot.skip(ftype)
5758 
      elif fid == 1:
5759 
        if ftype == TType.STRUCT:
5760 
          self.ucex = UserContextException()
5761 
          self.ucex.read(iprot)
5762 
        else:
5763 
          iprot.skip(ftype)
5764 
      else:
5765 
        iprot.skip(ftype)
5766 
      iprot.readFieldEnd()
5767 
    iprot.readStructEnd()
5768 
 
5769 
  def write(self, oprot):
5770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5772 
      return
5326 rajveer 5773 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5774 
    if self.success is not None:
3032 mandeep.dh 5775 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5776 
      self.success.write(oprot)
5777 
      oprot.writeFieldEnd()
3431 rajveer 5778 
    if self.ucex is not None:
3032 mandeep.dh 5779 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5780 
      self.ucex.write(oprot)
5781 
      oprot.writeFieldEnd()
5782 
    oprot.writeFieldStop()
5783 
    oprot.writeStructEnd()
5784 
 
3431 rajveer 5785 
  def validate(self):
5786 
    return
5787 
 
5788 
 
3032 mandeep.dh 5789 
  def __repr__(self):
5790 
    L = ['%s=%r' % (key, value)
5791 
      for key, value in self.__dict__.iteritems()]
5792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5793 
 
5794 
  def __eq__(self, other):
5795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5796 
 
5797 
  def __ne__(self, other):
5798 
    return not (self == other)
5799 
 
5326 rajveer 5800 
class getUserByMobileNumber_args:
94 ashish 5801 
  """
5802 
  Attributes:
5326 rajveer 5803 
   - mobileNumber
94 ashish 5804 
  """
5805 
 
5806 
  thrift_spec = (
5807 
    None, # 0
5326 rajveer 5808 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5809 
  )
5810 
 
5326 rajveer 5811 
  def __init__(self, mobileNumber=None,):
5812 
    self.mobileNumber = mobileNumber
94 ashish 5813 
 
5814 
  def read(self, iprot):
5815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5817 
      return
5818 
    iprot.readStructBegin()
5819 
    while True:
5820 
      (fname, ftype, fid) = iprot.readFieldBegin()
5821 
      if ftype == TType.STOP:
5822 
        break
5823 
      if fid == 1:
5326 rajveer 5824 
        if ftype == TType.I64:
5825 
          self.mobileNumber = iprot.readI64();
94 ashish 5826 
        else:
5827 
          iprot.skip(ftype)
5828 
      else:
5829 
        iprot.skip(ftype)
5830 
      iprot.readFieldEnd()
5831 
    iprot.readStructEnd()
5832 
 
5833 
  def write(self, oprot):
5834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5836 
      return
5326 rajveer 5837 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5838 
    if self.mobileNumber is not None:
5839 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5840 
      oprot.writeI64(self.mobileNumber)
94 ashish 5841 
      oprot.writeFieldEnd()
5842 
    oprot.writeFieldStop()
5843 
    oprot.writeStructEnd()
5844 
 
3431 rajveer 5845 
  def validate(self):
5846 
    return
5847 
 
5848 
 
94 ashish 5849 
  def __repr__(self):
5850 
    L = ['%s=%r' % (key, value)
5851 
      for key, value in self.__dict__.iteritems()]
5852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5853 
 
5854 
  def __eq__(self, other):
5855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5856 
 
5857 
  def __ne__(self, other):
5858 
    return not (self == other)
5859 
 
5326 rajveer 5860 
class getUserByMobileNumber_result:
94 ashish 5861 
  """
5862 
  Attributes:
5863 
   - success
559 chandransh 5864 
   - ucex
94 ashish 5865 
  """
5866 
 
5867 
  thrift_spec = (
559 chandransh 5868 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5869 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5870 
  )
5871 
 
559 chandransh 5872 
  def __init__(self, success=None, ucex=None,):
94 ashish 5873 
    self.success = success
559 chandransh 5874 
    self.ucex = ucex
94 ashish 5875 
 
5876 
  def read(self, iprot):
5877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5879 
      return
5880 
    iprot.readStructBegin()
5881 
    while True:
5882 
      (fname, ftype, fid) = iprot.readFieldBegin()
5883 
      if ftype == TType.STOP:
5884 
        break
5885 
      if fid == 0:
5886 
        if ftype == TType.STRUCT:
559 chandransh 5887 
          self.success = User()
94 ashish 5888 
          self.success.read(iprot)
5889 
        else:
5890 
          iprot.skip(ftype)
5891 
      elif fid == 1:
5892 
        if ftype == TType.STRUCT:
559 chandransh 5893 
          self.ucex = UserContextException()
5894 
          self.ucex.read(iprot)
94 ashish 5895 
        else:
5896 
          iprot.skip(ftype)
5897 
      else:
5898 
        iprot.skip(ftype)
5899 
      iprot.readFieldEnd()
5900 
    iprot.readStructEnd()
5901 
 
5902 
  def write(self, oprot):
5903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5905 
      return
5326 rajveer 5906 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5907 
    if self.success is not None:
94 ashish 5908 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5909 
      self.success.write(oprot)
5910 
      oprot.writeFieldEnd()
3431 rajveer 5911 
    if self.ucex is not None:
559 chandransh 5912 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5913 
      self.ucex.write(oprot)
94 ashish 5914 
      oprot.writeFieldEnd()
5915 
    oprot.writeFieldStop()
5916 
    oprot.writeStructEnd()
5917 
 
3431 rajveer 5918 
  def validate(self):
5919 
    return
5920 
 
5921 
 
94 ashish 5922 
  def __repr__(self):
5923 
    L = ['%s=%r' % (key, value)
5924 
      for key, value in self.__dict__.iteritems()]
5925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5926 
 
5927 
  def __eq__(self, other):
5928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5929 
 
5930 
  def __ne__(self, other):
5931 
    return not (self == other)
5932 
 
5326 rajveer 5933 
class createUser_args:
94 ashish 5934 
  """
5935 
  Attributes:
559 chandransh 5936 
   - user
94 ashish 5937 
  """
5938 
 
5939 
  thrift_spec = (
5940 
    None, # 0
559 chandransh 5941 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5942 
  )
5943 
 
559 chandransh 5944 
  def __init__(self, user=None,):
5945 
    self.user = user
94 ashish 5946 
 
5947 
  def read(self, iprot):
5948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5950 
      return
5951 
    iprot.readStructBegin()
5952 
    while True:
5953 
      (fname, ftype, fid) = iprot.readFieldBegin()
5954 
      if ftype == TType.STOP:
5955 
        break
5956 
      if fid == 1:
559 chandransh 5957 
        if ftype == TType.STRUCT:
5958 
          self.user = User()
5959 
          self.user.read(iprot)
94 ashish 5960 
        else:
5961 
          iprot.skip(ftype)
5962 
      else:
5963 
        iprot.skip(ftype)
5964 
      iprot.readFieldEnd()
5965 
    iprot.readStructEnd()
5966 
 
5967 
  def write(self, oprot):
5968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5970 
      return
5326 rajveer 5971 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5972 
    if self.user is not None:
559 chandransh 5973 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5974 
      self.user.write(oprot)
94 ashish 5975 
      oprot.writeFieldEnd()
5976 
    oprot.writeFieldStop()
5977 
    oprot.writeStructEnd()
5978 
 
3431 rajveer 5979 
  def validate(self):
5980 
    return
5981 
 
5982 
 
94 ashish 5983 
  def __repr__(self):
5984 
    L = ['%s=%r' % (key, value)
5985 
      for key, value in self.__dict__.iteritems()]
5986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5987 
 
5988 
  def __eq__(self, other):
5989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5990 
 
5991 
  def __ne__(self, other):
5992 
    return not (self == other)
5993 
 
5326 rajveer 5994 
class createUser_result:
94 ashish 5995 
  """
5996 
  Attributes:
5997 
   - success
559 chandransh 5998 
   - ucex
94 ashish 5999 
  """
6000 
 
6001 
  thrift_spec = (
559 chandransh 6002 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6003 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6004 
  )
6005 
 
559 chandransh 6006 
  def __init__(self, success=None, ucex=None,):
94 ashish 6007 
    self.success = success
559 chandransh 6008 
    self.ucex = ucex
94 ashish 6009 
 
6010 
  def read(self, iprot):
6011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6013 
      return
6014 
    iprot.readStructBegin()
6015 
    while True:
6016 
      (fname, ftype, fid) = iprot.readFieldBegin()
6017 
      if ftype == TType.STOP:
6018 
        break
6019 
      if fid == 0:
6020 
        if ftype == TType.STRUCT:
559 chandransh 6021 
          self.success = User()
94 ashish 6022 
          self.success.read(iprot)
6023 
        else:
6024 
          iprot.skip(ftype)
6025 
      elif fid == 1:
6026 
        if ftype == TType.STRUCT:
559 chandransh 6027 
          self.ucex = UserContextException()
6028 
          self.ucex.read(iprot)
94 ashish 6029 
        else:
6030 
          iprot.skip(ftype)
6031 
      else:
6032 
        iprot.skip(ftype)
6033 
      iprot.readFieldEnd()
6034 
    iprot.readStructEnd()
6035 
 
6036 
  def write(self, oprot):
6037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6039 
      return
5326 rajveer 6040 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 6041 
    if self.success is not None:
94 ashish 6042 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6043 
      self.success.write(oprot)
6044 
      oprot.writeFieldEnd()
3431 rajveer 6045 
    if self.ucex is not None:
559 chandransh 6046 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6047 
      self.ucex.write(oprot)
94 ashish 6048 
      oprot.writeFieldEnd()
6049 
    oprot.writeFieldStop()
6050 
    oprot.writeStructEnd()
6051 
 
3431 rajveer 6052 
  def validate(self):
6053 
    return
6054 
 
6055 
 
94 ashish 6056 
  def __repr__(self):
6057 
    L = ['%s=%r' % (key, value)
6058 
      for key, value in self.__dict__.iteritems()]
6059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6060 
 
6061 
  def __eq__(self, other):
6062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6063 
 
6064 
  def __ne__(self, other):
6065 
    return not (self == other)
6066 
 
5326 rajveer 6067 
class updateUser_args:
94 ashish 6068 
  """
6069 
  Attributes:
5326 rajveer 6070 
   - user
94 ashish 6071 
  """
6072 
 
6073 
  thrift_spec = (
6074 
    None, # 0
5326 rajveer 6075 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6076 
  )
6077 
 
5326 rajveer 6078 
  def __init__(self, user=None,):
6079 
    self.user = user
94 ashish 6080 
 
6081 
  def read(self, iprot):
6082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6084 
      return
6085 
    iprot.readStructBegin()
6086 
    while True:
6087 
      (fname, ftype, fid) = iprot.readFieldBegin()
6088 
      if ftype == TType.STOP:
6089 
        break
6090 
      if fid == 1:
5326 rajveer 6091 
        if ftype == TType.STRUCT:
6092 
          self.user = User()
6093 
          self.user.read(iprot)
94 ashish 6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      else:
6097 
        iprot.skip(ftype)
6098 
      iprot.readFieldEnd()
6099 
    iprot.readStructEnd()
6100 
 
6101 
  def write(self, oprot):
6102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6104 
      return
5326 rajveer 6105 
    oprot.writeStructBegin('updateUser_args')
6106 
    if self.user is not None:
6107 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6108 
      self.user.write(oprot)
94 ashish 6109 
      oprot.writeFieldEnd()
6110 
    oprot.writeFieldStop()
6111 
    oprot.writeStructEnd()
6112 
 
3431 rajveer 6113 
  def validate(self):
6114 
    return
6115 
 
6116 
 
94 ashish 6117 
  def __repr__(self):
6118 
    L = ['%s=%r' % (key, value)
6119 
      for key, value in self.__dict__.iteritems()]
6120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6121 
 
6122 
  def __eq__(self, other):
6123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6124 
 
6125 
  def __ne__(self, other):
6126 
    return not (self == other)
6127 
 
5326 rajveer 6128 
class updateUser_result:
94 ashish 6129 
  """
6130 
  Attributes:
6131 
   - success
559 chandransh 6132 
   - ucex
94 ashish 6133 
  """
6134 
 
6135 
  thrift_spec = (
5326 rajveer 6136 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6137 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6138 
  )
6139 
 
559 chandransh 6140 
  def __init__(self, success=None, ucex=None,):
94 ashish 6141 
    self.success = success
559 chandransh 6142 
    self.ucex = ucex
94 ashish 6143 
 
6144 
  def read(self, iprot):
6145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6147 
      return
6148 
    iprot.readStructBegin()
6149 
    while True:
6150 
      (fname, ftype, fid) = iprot.readFieldBegin()
6151 
      if ftype == TType.STOP:
6152 
        break
6153 
      if fid == 0:
5326 rajveer 6154 
        if ftype == TType.STRUCT:
6155 
          self.success = User()
6156 
          self.success.read(iprot)
94 ashish 6157 
        else:
6158 
          iprot.skip(ftype)
6159 
      elif fid == 1:
6160 
        if ftype == TType.STRUCT:
559 chandransh 6161 
          self.ucex = UserContextException()
6162 
          self.ucex.read(iprot)
94 ashish 6163 
        else:
6164 
          iprot.skip(ftype)
6165 
      else:
6166 
        iprot.skip(ftype)
6167 
      iprot.readFieldEnd()
6168 
    iprot.readStructEnd()
6169 
 
6170 
  def write(self, oprot):
6171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6173 
      return
5326 rajveer 6174 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6175 
    if self.success is not None:
5326 rajveer 6176 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6177 
      self.success.write(oprot)
94 ashish 6178 
      oprot.writeFieldEnd()
3431 rajveer 6179 
    if self.ucex is not None:
559 chandransh 6180 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6181 
      self.ucex.write(oprot)
94 ashish 6182 
      oprot.writeFieldEnd()
6183 
    oprot.writeFieldStop()
6184 
    oprot.writeStructEnd()
6185 
 
3431 rajveer 6186 
  def validate(self):
6187 
    return
6188 
 
6189 
 
94 ashish 6190 
  def __repr__(self):
6191 
    L = ['%s=%r' % (key, value)
6192 
      for key, value in self.__dict__.iteritems()]
6193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6194 
 
6195 
  def __eq__(self, other):
6196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6197 
 
6198 
  def __ne__(self, other):
6199 
    return not (self == other)
6200 
 
559 chandransh 6201 
class authenticateUser_args:
94 ashish 6202 
  """
6203 
  Attributes:
6204 
   - email
6205 
   - password
6206 
  """
6207 
 
6208 
  thrift_spec = (
6209 
    None, # 0
6210 
    (1, TType.STRING, 'email', None, None, ), # 1
6211 
    (2, TType.STRING, 'password', None, None, ), # 2
6212 
  )
6213 
 
6214 
  def __init__(self, email=None, password=None,):
6215 
    self.email = email
6216 
    self.password = password
6217 
 
6218 
  def read(self, iprot):
6219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6221 
      return
6222 
    iprot.readStructBegin()
6223 
    while True:
6224 
      (fname, ftype, fid) = iprot.readFieldBegin()
6225 
      if ftype == TType.STOP:
6226 
        break
6227 
      if fid == 1:
6228 
        if ftype == TType.STRING:
6229 
          self.email = iprot.readString();
6230 
        else:
6231 
          iprot.skip(ftype)
6232 
      elif fid == 2:
6233 
        if ftype == TType.STRING:
6234 
          self.password = iprot.readString();
6235 
        else:
6236 
          iprot.skip(ftype)
6237 
      else:
6238 
        iprot.skip(ftype)
6239 
      iprot.readFieldEnd()
6240 
    iprot.readStructEnd()
6241 
 
6242 
  def write(self, oprot):
6243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6245 
      return
559 chandransh 6246 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6247 
    if self.email is not None:
94 ashish 6248 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6249 
      oprot.writeString(self.email)
6250 
      oprot.writeFieldEnd()
3431 rajveer 6251 
    if self.password is not None:
94 ashish 6252 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6253 
      oprot.writeString(self.password)
6254 
      oprot.writeFieldEnd()
6255 
    oprot.writeFieldStop()
6256 
    oprot.writeStructEnd()
6257 
 
3431 rajveer 6258 
  def validate(self):
6259 
    return
6260 
 
6261 
 
94 ashish 6262 
  def __repr__(self):
6263 
    L = ['%s=%r' % (key, value)
6264 
      for key, value in self.__dict__.iteritems()]
6265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6266 
 
6267 
  def __eq__(self, other):
6268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6269 
 
6270 
  def __ne__(self, other):
6271 
    return not (self == other)
6272 
 
559 chandransh 6273 
class authenticateUser_result:
94 ashish 6274 
  """
6275 
  Attributes:
6276 
   - success
559 chandransh 6277 
   - auex
94 ashish 6278 
  """
6279 
 
6280 
  thrift_spec = (
559 chandransh 6281 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6282 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6283 
  )
6284 
 
559 chandransh 6285 
  def __init__(self, success=None, auex=None,):
94 ashish 6286 
    self.success = success
559 chandransh 6287 
    self.auex = auex
94 ashish 6288 
 
6289 
  def read(self, iprot):
6290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6292 
      return
6293 
    iprot.readStructBegin()
6294 
    while True:
6295 
      (fname, ftype, fid) = iprot.readFieldBegin()
6296 
      if ftype == TType.STOP:
6297 
        break
6298 
      if fid == 0:
6299 
        if ftype == TType.STRUCT:
559 chandransh 6300 
          self.success = User()
94 ashish 6301 
          self.success.read(iprot)
6302 
        else:
6303 
          iprot.skip(ftype)
6304 
      elif fid == 1:
6305 
        if ftype == TType.STRUCT:
559 chandransh 6306 
          self.auex = AuthenticationException()
6307 
          self.auex.read(iprot)
94 ashish 6308 
        else:
6309 
          iprot.skip(ftype)
6310 
      else:
6311 
        iprot.skip(ftype)
6312 
      iprot.readFieldEnd()
6313 
    iprot.readStructEnd()
6314 
 
6315 
  def write(self, oprot):
6316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6318 
      return
559 chandransh 6319 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6320 
    if self.success is not None:
94 ashish 6321 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6322 
      self.success.write(oprot)
6323 
      oprot.writeFieldEnd()
3431 rajveer 6324 
    if self.auex is not None:
559 chandransh 6325 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6326 
      self.auex.write(oprot)
94 ashish 6327 
      oprot.writeFieldEnd()
6328 
    oprot.writeFieldStop()
6329 
    oprot.writeStructEnd()
6330 
 
3431 rajveer 6331 
  def validate(self):
6332 
    return
6333 
 
6334 
 
94 ashish 6335 
  def __repr__(self):
6336 
    L = ['%s=%r' % (key, value)
6337 
      for key, value in self.__dict__.iteritems()]
6338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6339 
 
6340 
  def __eq__(self, other):
6341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6342 
 
6343 
  def __ne__(self, other):
6344 
    return not (self == other)
6345 
 
559 chandransh 6346 
class userExists_args:
122 ashish 6347 
  """
6348 
  Attributes:
559 chandransh 6349 
   - email
122 ashish 6350 
  """
6351 
 
6352 
  thrift_spec = (
6353 
    None, # 0
559 chandransh 6354 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6355 
  )
6356 
 
559 chandransh 6357 
  def __init__(self, email=None,):
6358 
    self.email = email
122 ashish 6359 
 
6360 
  def read(self, iprot):
6361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6363 
      return
6364 
    iprot.readStructBegin()
6365 
    while True:
6366 
      (fname, ftype, fid) = iprot.readFieldBegin()
6367 
      if ftype == TType.STOP:
6368 
        break
6369 
      if fid == 1:
6370 
        if ftype == TType.STRING:
559 chandransh 6371 
          self.email = iprot.readString();
122 ashish 6372 
        else:
6373 
          iprot.skip(ftype)
559 chandransh 6374 
      else:
6375 
        iprot.skip(ftype)
6376 
      iprot.readFieldEnd()
6377 
    iprot.readStructEnd()
6378 
 
6379 
  def write(self, oprot):
6380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6382 
      return
6383 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6384 
    if self.email is not None:
559 chandransh 6385 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6386 
      oprot.writeString(self.email)
6387 
      oprot.writeFieldEnd()
6388 
    oprot.writeFieldStop()
6389 
    oprot.writeStructEnd()
6390 
 
3431 rajveer 6391 
  def validate(self):
6392 
    return
6393 
 
6394 
 
559 chandransh 6395 
  def __repr__(self):
6396 
    L = ['%s=%r' % (key, value)
6397 
      for key, value in self.__dict__.iteritems()]
6398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6399 
 
6400 
  def __eq__(self, other):
6401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6402 
 
6403 
  def __ne__(self, other):
6404 
    return not (self == other)
6405 
 
6406 
class userExists_result:
6407 
  """
6408 
  Attributes:
6409 
   - success
6410 
   - ucx
6411 
  """
6412 
 
6413 
  thrift_spec = (
6414 
    (0, TType.BOOL, 'success', None, None, ), # 0
6415 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6416 
  )
6417 
 
6418 
  def __init__(self, success=None, ucx=None,):
6419 
    self.success = success
6420 
    self.ucx = ucx
6421 
 
6422 
  def read(self, iprot):
6423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6425 
      return
6426 
    iprot.readStructBegin()
6427 
    while True:
6428 
      (fname, ftype, fid) = iprot.readFieldBegin()
6429 
      if ftype == TType.STOP:
6430 
        break
6431 
      if fid == 0:
6432 
        if ftype == TType.BOOL:
6433 
          self.success = iprot.readBool();
6434 
        else:
6435 
          iprot.skip(ftype)
6436 
      elif fid == 1:
6437 
        if ftype == TType.STRUCT:
6438 
          self.ucx = UserContextException()
6439 
          self.ucx.read(iprot)
6440 
        else:
6441 
          iprot.skip(ftype)
6442 
      else:
6443 
        iprot.skip(ftype)
6444 
      iprot.readFieldEnd()
6445 
    iprot.readStructEnd()
6446 
 
6447 
  def write(self, oprot):
6448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6450 
      return
6451 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6452 
    if self.success is not None:
559 chandransh 6453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6454 
      oprot.writeBool(self.success)
6455 
      oprot.writeFieldEnd()
3431 rajveer 6456 
    if self.ucx is not None:
559 chandransh 6457 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6458 
      self.ucx.write(oprot)
6459 
      oprot.writeFieldEnd()
6460 
    oprot.writeFieldStop()
6461 
    oprot.writeStructEnd()
6462 
 
3431 rajveer 6463 
  def validate(self):
6464 
    return
6465 
 
6466 
 
559 chandransh 6467 
  def __repr__(self):
6468 
    L = ['%s=%r' % (key, value)
6469 
      for key, value in self.__dict__.iteritems()]
6470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6471 
 
6472 
  def __eq__(self, other):
6473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6474 
 
6475 
  def __ne__(self, other):
6476 
    return not (self == other)
6477 
 
6478 
class addAddressForUser_args:
6479 
  """
6480 
  Attributes:
6481 
   - userId
6482 
   - address
6483 
   - setDefault
6484 
  """
6485 
 
6486 
  thrift_spec = (
6487 
    None, # 0
6488 
    (1, TType.I64, 'userId', None, None, ), # 1
6489 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6490 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6491 
  )
6492 
 
567 rajveer 6493 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6494 
    self.userId = userId
6495 
    self.address = address
6496 
    self.setDefault = setDefault
6497 
 
6498 
  def read(self, iprot):
6499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6501 
      return
6502 
    iprot.readStructBegin()
6503 
    while True:
6504 
      (fname, ftype, fid) = iprot.readFieldBegin()
6505 
      if ftype == TType.STOP:
6506 
        break
6507 
      if fid == 1:
6508 
        if ftype == TType.I64:
6509 
          self.userId = iprot.readI64();
6510 
        else:
6511 
          iprot.skip(ftype)
122 ashish 6512 
      elif fid == 2:
559 chandransh 6513 
        if ftype == TType.STRUCT:
6514 
          self.address = Address()
6515 
          self.address.read(iprot)
122 ashish 6516 
        else:
6517 
          iprot.skip(ftype)
6518 
      elif fid == 3:
6519 
        if ftype == TType.BOOL:
559 chandransh 6520 
          self.setDefault = iprot.readBool();
122 ashish 6521 
        else:
6522 
          iprot.skip(ftype)
6523 
      else:
6524 
        iprot.skip(ftype)
6525 
      iprot.readFieldEnd()
6526 
    iprot.readStructEnd()
6527 
 
6528 
  def write(self, oprot):
6529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6531 
      return
559 chandransh 6532 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6533 
    if self.userId is not None:
559 chandransh 6534 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6535 
      oprot.writeI64(self.userId)
122 ashish 6536 
      oprot.writeFieldEnd()
3431 rajveer 6537 
    if self.address is not None:
559 chandransh 6538 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6539 
      self.address.write(oprot)
122 ashish 6540 
      oprot.writeFieldEnd()
3431 rajveer 6541 
    if self.setDefault is not None:
567 rajveer 6542 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6543 
      oprot.writeBool(self.setDefault)
6544 
      oprot.writeFieldEnd()
122 ashish 6545 
    oprot.writeFieldStop()
6546 
    oprot.writeStructEnd()
6547 
 
3431 rajveer 6548 
  def validate(self):
6549 
    return
6550 
 
6551 
 
122 ashish 6552 
  def __repr__(self):
6553 
    L = ['%s=%r' % (key, value)
6554 
      for key, value in self.__dict__.iteritems()]
6555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6556 
 
6557 
  def __eq__(self, other):
6558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6559 
 
6560 
  def __ne__(self, other):
6561 
    return not (self == other)
6562 
 
559 chandransh 6563 
class addAddressForUser_result:
122 ashish 6564 
  """
6565 
  Attributes:
6566 
   - success
559 chandransh 6567 
   - ucx
122 ashish 6568 
  """
6569 
 
6570 
  thrift_spec = (
567 rajveer 6571 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6572 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6573 
  )
6574 
 
559 chandransh 6575 
  def __init__(self, success=None, ucx=None,):
122 ashish 6576 
    self.success = success
559 chandransh 6577 
    self.ucx = ucx
122 ashish 6578 
 
6579 
  def read(self, iprot):
6580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6582 
      return
6583 
    iprot.readStructBegin()
6584 
    while True:
6585 
      (fname, ftype, fid) = iprot.readFieldBegin()
6586 
      if ftype == TType.STOP:
6587 
        break
6588 
      if fid == 0:
567 rajveer 6589 
        if ftype == TType.I64:
6590 
          self.success = iprot.readI64();
122 ashish 6591 
        else:
6592 
          iprot.skip(ftype)
6593 
      elif fid == 1:
6594 
        if ftype == TType.STRUCT:
559 chandransh 6595 
          self.ucx = UserContextException()
6596 
          self.ucx.read(iprot)
122 ashish 6597 
        else:
6598 
          iprot.skip(ftype)
6599 
      else:
6600 
        iprot.skip(ftype)
6601 
      iprot.readFieldEnd()
6602 
    iprot.readStructEnd()
6603 
 
6604 
  def write(self, oprot):
6605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6607 
      return
559 chandransh 6608 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6609 
    if self.success is not None:
567 rajveer 6610 
      oprot.writeFieldBegin('success', TType.I64, 0)
6611 
      oprot.writeI64(self.success)
122 ashish 6612 
      oprot.writeFieldEnd()
3431 rajveer 6613 
    if self.ucx is not None:
559 chandransh 6614 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6615 
      self.ucx.write(oprot)
122 ashish 6616 
      oprot.writeFieldEnd()
6617 
    oprot.writeFieldStop()
6618 
    oprot.writeStructEnd()
6619 
 
3431 rajveer 6620 
  def validate(self):
6621 
    return
6622 
 
6623 
 
122 ashish 6624 
  def __repr__(self):
6625 
    L = ['%s=%r' % (key, value)
6626 
      for key, value in self.__dict__.iteritems()]
6627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6628 
 
6629 
  def __eq__(self, other):
6630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6631 
 
6632 
  def __ne__(self, other):
6633 
    return not (self == other)
6634 
 
559 chandransh 6635 
class removeAddressForUser_args:
94 ashish 6636 
  """
6637 
  Attributes:
559 chandransh 6638 
   - userid
6639 
   - addressId
94 ashish 6640 
  """
6641 
 
6642 
  thrift_spec = (
6643 
    None, # 0
559 chandransh 6644 
    (1, TType.I64, 'userid', None, None, ), # 1
6645 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6646 
  )
6647 
 
559 chandransh 6648 
  def __init__(self, userid=None, addressId=None,):
6649 
    self.userid = userid
6650 
    self.addressId = addressId
94 ashish 6651 
 
6652 
  def read(self, iprot):
6653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6655 
      return
6656 
    iprot.readStructBegin()
6657 
    while True:
6658 
      (fname, ftype, fid) = iprot.readFieldBegin()
6659 
      if ftype == TType.STOP:
6660 
        break
6661 
      if fid == 1:
559 chandransh 6662 
        if ftype == TType.I64:
6663 
          self.userid = iprot.readI64();
94 ashish 6664 
        else:
6665 
          iprot.skip(ftype)
559 chandransh 6666 
      elif fid == 2:
6667 
        if ftype == TType.I64:
6668 
          self.addressId = iprot.readI64();
6669 
        else:
6670 
          iprot.skip(ftype)
94 ashish 6671 
      else:
6672 
        iprot.skip(ftype)
6673 
      iprot.readFieldEnd()
6674 
    iprot.readStructEnd()
6675 
 
6676 
  def write(self, oprot):
6677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6679 
      return
559 chandransh 6680 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6681 
    if self.userid is not None:
559 chandransh 6682 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6683 
      oprot.writeI64(self.userid)
94 ashish 6684 
      oprot.writeFieldEnd()
3431 rajveer 6685 
    if self.addressId is not None:
559 chandransh 6686 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6687 
      oprot.writeI64(self.addressId)
6688 
      oprot.writeFieldEnd()
94 ashish 6689 
    oprot.writeFieldStop()
6690 
    oprot.writeStructEnd()
6691 
 
3431 rajveer 6692 
  def validate(self):
6693 
    return
6694 
 
6695 
 
94 ashish 6696 
  def __repr__(self):
6697 
    L = ['%s=%r' % (key, value)
6698 
      for key, value in self.__dict__.iteritems()]
6699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6700 
 
6701 
  def __eq__(self, other):
6702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6703 
 
6704 
  def __ne__(self, other):
6705 
    return not (self == other)
6706 
 
559 chandransh 6707 
class removeAddressForUser_result:
94 ashish 6708 
  """
6709 
  Attributes:
6710 
   - success
6711 
   - ucx
6712 
  """
6713 
 
6714 
  thrift_spec = (
6715 
    (0, TType.BOOL, 'success', None, None, ), # 0
6716 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6717 
  )
6718 
 
6719 
  def __init__(self, success=None, ucx=None,):
6720 
    self.success = success
6721 
    self.ucx = ucx
6722 
 
6723 
  def read(self, iprot):
6724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6726 
      return
6727 
    iprot.readStructBegin()
6728 
    while True:
6729 
      (fname, ftype, fid) = iprot.readFieldBegin()
6730 
      if ftype == TType.STOP:
6731 
        break
6732 
      if fid == 0:
6733 
        if ftype == TType.BOOL:
6734 
          self.success = iprot.readBool();
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      elif fid == 1:
6738 
        if ftype == TType.STRUCT:
6739 
          self.ucx = UserContextException()
6740 
          self.ucx.read(iprot)
6741 
        else:
6742 
          iprot.skip(ftype)
6743 
      else:
6744 
        iprot.skip(ftype)
6745 
      iprot.readFieldEnd()
6746 
    iprot.readStructEnd()
6747 
 
6748 
  def write(self, oprot):
6749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6751 
      return
559 chandransh 6752 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6753 
    if self.success is not None:
94 ashish 6754 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6755 
      oprot.writeBool(self.success)
6756 
      oprot.writeFieldEnd()
3431 rajveer 6757 
    if self.ucx is not None:
94 ashish 6758 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6759 
      self.ucx.write(oprot)
6760 
      oprot.writeFieldEnd()
6761 
    oprot.writeFieldStop()
6762 
    oprot.writeStructEnd()
6763 
 
3431 rajveer 6764 
  def validate(self):
6765 
    return
6766 
 
6767 
 
94 ashish 6768 
  def __repr__(self):
6769 
    L = ['%s=%r' % (key, value)
6770 
      for key, value in self.__dict__.iteritems()]
6771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6772 
 
6773 
  def __eq__(self, other):
6774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6775 
 
6776 
  def __ne__(self, other):
6777 
    return not (self == other)
6778 
 
559 chandransh 6779 
class setUserAsLoggedIn_args:
94 ashish 6780 
  """
6781 
  Attributes:
559 chandransh 6782 
   - userId
94 ashish 6783 
   - timestamp
6784 
  """
6785 
 
6786 
  thrift_spec = (
6787 
    None, # 0
559 chandransh 6788 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6789 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6790 
  )
6791 
 
559 chandransh 6792 
  def __init__(self, userId=None, timestamp=None,):
6793 
    self.userId = userId
94 ashish 6794 
    self.timestamp = timestamp
6795 
 
6796 
  def read(self, iprot):
6797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6799 
      return
6800 
    iprot.readStructBegin()
6801 
    while True:
6802 
      (fname, ftype, fid) = iprot.readFieldBegin()
6803 
      if ftype == TType.STOP:
6804 
        break
6805 
      if fid == 1:
559 chandransh 6806 
        if ftype == TType.I64:
6807 
          self.userId = iprot.readI64();
94 ashish 6808 
        else:
6809 
          iprot.skip(ftype)
6810 
      elif fid == 2:
6811 
        if ftype == TType.I64:
6812 
          self.timestamp = iprot.readI64();
6813 
        else:
6814 
          iprot.skip(ftype)
6815 
      else:
6816 
        iprot.skip(ftype)
6817 
      iprot.readFieldEnd()
6818 
    iprot.readStructEnd()
6819 
 
6820 
  def write(self, oprot):
6821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6823 
      return
559 chandransh 6824 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6825 
    if self.userId is not None:
559 chandransh 6826 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6827 
      oprot.writeI64(self.userId)
94 ashish 6828 
      oprot.writeFieldEnd()
3431 rajveer 6829 
    if self.timestamp is not None:
94 ashish 6830 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6831 
      oprot.writeI64(self.timestamp)
6832 
      oprot.writeFieldEnd()
6833 
    oprot.writeFieldStop()
6834 
    oprot.writeStructEnd()
6835 
 
3431 rajveer 6836 
  def validate(self):
6837 
    return
6838 
 
6839 
 
94 ashish 6840 
  def __repr__(self):
6841 
    L = ['%s=%r' % (key, value)
6842 
      for key, value in self.__dict__.iteritems()]
6843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6844 
 
6845 
  def __eq__(self, other):
6846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6847 
 
6848 
  def __ne__(self, other):
6849 
    return not (self == other)
6850 
 
559 chandransh 6851 
class setUserAsLoggedIn_result:
94 ashish 6852 
  """
6853 
  Attributes:
6854 
   - success
6855 
   - ucx
6856 
  """
6857 
 
6858 
  thrift_spec = (
6859 
    (0, TType.BOOL, 'success', None, None, ), # 0
6860 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6861 
  )
6862 
 
6863 
  def __init__(self, success=None, ucx=None,):
6864 
    self.success = success
6865 
    self.ucx = ucx
6866 
 
6867 
  def read(self, iprot):
6868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6870 
      return
6871 
    iprot.readStructBegin()
6872 
    while True:
6873 
      (fname, ftype, fid) = iprot.readFieldBegin()
6874 
      if ftype == TType.STOP:
6875 
        break
6876 
      if fid == 0:
6877 
        if ftype == TType.BOOL:
6878 
          self.success = iprot.readBool();
6879 
        else:
6880 
          iprot.skip(ftype)
6881 
      elif fid == 1:
6882 
        if ftype == TType.STRUCT:
6883 
          self.ucx = UserContextException()
6884 
          self.ucx.read(iprot)
6885 
        else:
6886 
          iprot.skip(ftype)
6887 
      else:
6888 
        iprot.skip(ftype)
6889 
      iprot.readFieldEnd()
6890 
    iprot.readStructEnd()
6891 
 
6892 
  def write(self, oprot):
6893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6895 
      return
559 chandransh 6896 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6897 
    if self.success is not None:
94 ashish 6898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6899 
      oprot.writeBool(self.success)
6900 
      oprot.writeFieldEnd()
3431 rajveer 6901 
    if self.ucx is not None:
94 ashish 6902 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6903 
      self.ucx.write(oprot)
6904 
      oprot.writeFieldEnd()
6905 
    oprot.writeFieldStop()
6906 
    oprot.writeStructEnd()
6907 
 
3431 rajveer 6908 
  def validate(self):
6909 
    return
6910 
 
6911 
 
94 ashish 6912 
  def __repr__(self):
6913 
    L = ['%s=%r' % (key, value)
6914 
      for key, value in self.__dict__.iteritems()]
6915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6916 
 
6917 
  def __eq__(self, other):
6918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6919 
 
6920 
  def __ne__(self, other):
6921 
    return not (self == other)
6922 
 
559 chandransh 6923 
class setUserAsLoggedOut_args:
94 ashish 6924 
  """
6925 
  Attributes:
6926 
   - userid
6927 
   - timestamp
6928 
  """
6929 
 
6930 
  thrift_spec = (
6931 
    None, # 0
559 chandransh 6932 
    (1, TType.I64, 'userid', None, None, ), # 1
6933 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6934 
  )
6935 
 
559 chandransh 6936 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6937 
    self.userid = userid
6938 
    self.timestamp = timestamp
6939 
 
6940 
  def read(self, iprot):
6941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6943 
      return
6944 
    iprot.readStructBegin()
6945 
    while True:
6946 
      (fname, ftype, fid) = iprot.readFieldBegin()
6947 
      if ftype == TType.STOP:
6948 
        break
6949 
      if fid == 1:
6950 
        if ftype == TType.I64:
6951 
          self.userid = iprot.readI64();
6952 
        else:
6953 
          iprot.skip(ftype)
559 chandransh 6954 
      elif fid == 2:
94 ashish 6955 
        if ftype == TType.I64:
6956 
          self.timestamp = iprot.readI64();
6957 
        else:
6958 
          iprot.skip(ftype)
6959 
      else:
6960 
        iprot.skip(ftype)
6961 
      iprot.readFieldEnd()
6962 
    iprot.readStructEnd()
6963 
 
6964 
  def write(self, oprot):
6965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6967 
      return
559 chandransh 6968 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6969 
    if self.userid is not None:
559 chandransh 6970 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6971 
      oprot.writeI64(self.userid)
6972 
      oprot.writeFieldEnd()
3431 rajveer 6973 
    if self.timestamp is not None:
559 chandransh 6974 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6975 
      oprot.writeI64(self.timestamp)
6976 
      oprot.writeFieldEnd()
6977 
    oprot.writeFieldStop()
6978 
    oprot.writeStructEnd()
6979 
 
3431 rajveer 6980 
  def validate(self):
6981 
    return
6982 
 
6983 
 
94 ashish 6984 
  def __repr__(self):
6985 
    L = ['%s=%r' % (key, value)
6986 
      for key, value in self.__dict__.iteritems()]
6987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6988 
 
6989 
  def __eq__(self, other):
6990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6991 
 
6992 
  def __ne__(self, other):
6993 
    return not (self == other)
6994 
 
559 chandransh 6995 
class setUserAsLoggedOut_result:
94 ashish 6996 
  """
6997 
  Attributes:
6998 
   - success
6999 
   - ucx
7000 
  """
7001 
 
7002 
  thrift_spec = (
7003 
    (0, TType.BOOL, 'success', None, None, ), # 0
7004 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7005 
  )
7006 
 
7007 
  def __init__(self, success=None, ucx=None,):
7008 
    self.success = success
7009 
    self.ucx = ucx
7010 
 
7011 
  def read(self, iprot):
7012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7014 
      return
7015 
    iprot.readStructBegin()
7016 
    while True:
7017 
      (fname, ftype, fid) = iprot.readFieldBegin()
7018 
      if ftype == TType.STOP:
7019 
        break
7020 
      if fid == 0:
7021 
        if ftype == TType.BOOL:
7022 
          self.success = iprot.readBool();
7023 
        else:
7024 
          iprot.skip(ftype)
7025 
      elif fid == 1:
7026 
        if ftype == TType.STRUCT:
7027 
          self.ucx = UserContextException()
7028 
          self.ucx.read(iprot)
7029 
        else:
7030 
          iprot.skip(ftype)
7031 
      else:
7032 
        iprot.skip(ftype)
7033 
      iprot.readFieldEnd()
7034 
    iprot.readStructEnd()
7035 
 
7036 
  def write(self, oprot):
7037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7039 
      return
559 chandransh 7040 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 7041 
    if self.success is not None:
94 ashish 7042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7043 
      oprot.writeBool(self.success)
7044 
      oprot.writeFieldEnd()
3431 rajveer 7045 
    if self.ucx is not None:
94 ashish 7046 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7047 
      self.ucx.write(oprot)
7048 
      oprot.writeFieldEnd()
7049 
    oprot.writeFieldStop()
7050 
    oprot.writeStructEnd()
7051 
 
3431 rajveer 7052 
  def validate(self):
7053 
    return
7054 
 
7055 
 
94 ashish 7056 
  def __repr__(self):
7057 
    L = ['%s=%r' % (key, value)
7058 
      for key, value in self.__dict__.iteritems()]
7059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7060 
 
7061 
  def __eq__(self, other):
7062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7063 
 
7064 
  def __ne__(self, other):
7065 
    return not (self == other)
7066 
 
559 chandransh 7067 
class setDefaultAddress_args:
94 ashish 7068 
  """
7069 
  Attributes:
7070 
   - userid
7071 
   - addressId
7072 
  """
7073 
 
7074 
  thrift_spec = (
7075 
    None, # 0
7076 
    (1, TType.I64, 'userid', None, None, ), # 1
7077 
    (2, TType.I64, 'addressId', None, None, ), # 2
7078 
  )
7079 
 
7080 
  def __init__(self, userid=None, addressId=None,):
7081 
    self.userid = userid
7082 
    self.addressId = addressId
7083 
 
7084 
  def read(self, iprot):
7085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7087 
      return
7088 
    iprot.readStructBegin()
7089 
    while True:
7090 
      (fname, ftype, fid) = iprot.readFieldBegin()
7091 
      if ftype == TType.STOP:
7092 
        break
7093 
      if fid == 1:
7094 
        if ftype == TType.I64:
7095 
          self.userid = iprot.readI64();
7096 
        else:
7097 
          iprot.skip(ftype)
7098 
      elif fid == 2:
7099 
        if ftype == TType.I64:
7100 
          self.addressId = iprot.readI64();
7101 
        else:
7102 
          iprot.skip(ftype)
7103 
      else:
7104 
        iprot.skip(ftype)
7105 
      iprot.readFieldEnd()
7106 
    iprot.readStructEnd()
7107 
 
7108 
  def write(self, oprot):
7109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7111 
      return
559 chandransh 7112 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7113 
    if self.userid is not None:
94 ashish 7114 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7115 
      oprot.writeI64(self.userid)
7116 
      oprot.writeFieldEnd()
3431 rajveer 7117 
    if self.addressId is not None:
94 ashish 7118 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7119 
      oprot.writeI64(self.addressId)
7120 
      oprot.writeFieldEnd()
7121 
    oprot.writeFieldStop()
7122 
    oprot.writeStructEnd()
7123 
 
3431 rajveer 7124 
  def validate(self):
7125 
    return
7126 
 
7127 
 
94 ashish 7128 
  def __repr__(self):
7129 
    L = ['%s=%r' % (key, value)
7130 
      for key, value in self.__dict__.iteritems()]
7131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7132 
 
7133 
  def __eq__(self, other):
7134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7135 
 
7136 
  def __ne__(self, other):
7137 
    return not (self == other)
7138 
 
559 chandransh 7139 
class setDefaultAddress_result:
94 ashish 7140 
  """
7141 
  Attributes:
7142 
   - success
7143 
   - ucx
7144 
  """
7145 
 
7146 
  thrift_spec = (
7147 
    (0, TType.BOOL, 'success', None, None, ), # 0
7148 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7149 
  )
7150 
 
7151 
  def __init__(self, success=None, ucx=None,):
7152 
    self.success = success
7153 
    self.ucx = ucx
7154 
 
7155 
  def read(self, iprot):
7156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7158 
      return
7159 
    iprot.readStructBegin()
7160 
    while True:
7161 
      (fname, ftype, fid) = iprot.readFieldBegin()
7162 
      if ftype == TType.STOP:
7163 
        break
7164 
      if fid == 0:
7165 
        if ftype == TType.BOOL:
7166 
          self.success = iprot.readBool();
7167 
        else:
7168 
          iprot.skip(ftype)
7169 
      elif fid == 1:
7170 
        if ftype == TType.STRUCT:
7171 
          self.ucx = UserContextException()
7172 
          self.ucx.read(iprot)
7173 
        else:
7174 
          iprot.skip(ftype)
7175 
      else:
7176 
        iprot.skip(ftype)
7177 
      iprot.readFieldEnd()
7178 
    iprot.readStructEnd()
7179 
 
7180 
  def write(self, oprot):
7181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7183 
      return
559 chandransh 7184 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7185 
    if self.success is not None:
94 ashish 7186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7187 
      oprot.writeBool(self.success)
7188 
      oprot.writeFieldEnd()
3431 rajveer 7189 
    if self.ucx is not None:
94 ashish 7190 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7191 
      self.ucx.write(oprot)
7192 
      oprot.writeFieldEnd()
7193 
    oprot.writeFieldStop()
7194 
    oprot.writeStructEnd()
7195 
 
3431 rajveer 7196 
  def validate(self):
7197 
    return
7198 
 
7199 
 
94 ashish 7200 
  def __repr__(self):
7201 
    L = ['%s=%r' % (key, value)
7202 
      for key, value in self.__dict__.iteritems()]
7203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7204 
 
7205 
  def __eq__(self, other):
7206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7207 
 
7208 
  def __ne__(self, other):
7209 
    return not (self == other)
7210 
 
559 chandransh 7211 
class updatePassword_args:
94 ashish 7212 
  """
7213 
  Attributes:
559 chandransh 7214 
   - userid
594 rajveer 7215 
   - oldPassword
7216 
   - newPassword
94 ashish 7217 
  """
7218 
 
7219 
  thrift_spec = (
7220 
    None, # 0
559 chandransh 7221 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7222 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7223 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7224 
  )
7225 
 
594 rajveer 7226 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7227 
    self.userid = userid
594 rajveer 7228 
    self.oldPassword = oldPassword
7229 
    self.newPassword = newPassword
94 ashish 7230 
 
7231 
  def read(self, iprot):
7232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7234 
      return
7235 
    iprot.readStructBegin()
7236 
    while True:
7237 
      (fname, ftype, fid) = iprot.readFieldBegin()
7238 
      if ftype == TType.STOP:
7239 
        break
7240 
      if fid == 1:
7241 
        if ftype == TType.I64:
559 chandransh 7242 
          self.userid = iprot.readI64();
94 ashish 7243 
        else:
7244 
          iprot.skip(ftype)
7245 
      elif fid == 2:
559 chandransh 7246 
        if ftype == TType.STRING:
594 rajveer 7247 
          self.oldPassword = iprot.readString();
94 ashish 7248 
        else:
7249 
          iprot.skip(ftype)
594 rajveer 7250 
      elif fid == 3:
7251 
        if ftype == TType.STRING:
7252 
          self.newPassword = iprot.readString();
7253 
        else:
7254 
          iprot.skip(ftype)
94 ashish 7255 
      else:
7256 
        iprot.skip(ftype)
7257 
      iprot.readFieldEnd()
7258 
    iprot.readStructEnd()
7259 
 
7260 
  def write(self, oprot):
7261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7263 
      return
559 chandransh 7264 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7265 
    if self.userid is not None:
559 chandransh 7266 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7267 
      oprot.writeI64(self.userid)
94 ashish 7268 
      oprot.writeFieldEnd()
3431 rajveer 7269 
    if self.oldPassword is not None:
594 rajveer 7270 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7271 
      oprot.writeString(self.oldPassword)
94 ashish 7272 
      oprot.writeFieldEnd()
3431 rajveer 7273 
    if self.newPassword is not None:
594 rajveer 7274 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7275 
      oprot.writeString(self.newPassword)
7276 
      oprot.writeFieldEnd()
94 ashish 7277 
    oprot.writeFieldStop()
7278 
    oprot.writeStructEnd()
7279 
 
3431 rajveer 7280 
  def validate(self):
7281 
    return
7282 
 
7283 
 
94 ashish 7284 
  def __repr__(self):
7285 
    L = ['%s=%r' % (key, value)
7286 
      for key, value in self.__dict__.iteritems()]
7287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7288 
 
7289 
  def __eq__(self, other):
7290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7291 
 
7292 
  def __ne__(self, other):
7293 
    return not (self == other)
7294 
 
559 chandransh 7295 
class updatePassword_result:
94 ashish 7296 
  """
7297 
  Attributes:
7298 
   - success
7299 
   - ucx
7300 
  """
7301 
 
7302 
  thrift_spec = (
7303 
    (0, TType.BOOL, 'success', None, None, ), # 0
7304 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7305 
  )
7306 
 
7307 
  def __init__(self, success=None, ucx=None,):
7308 
    self.success = success
7309 
    self.ucx = ucx
7310 
 
7311 
  def read(self, iprot):
7312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7314 
      return
7315 
    iprot.readStructBegin()
7316 
    while True:
7317 
      (fname, ftype, fid) = iprot.readFieldBegin()
7318 
      if ftype == TType.STOP:
7319 
        break
7320 
      if fid == 0:
7321 
        if ftype == TType.BOOL:
7322 
          self.success = iprot.readBool();
7323 
        else:
7324 
          iprot.skip(ftype)
7325 
      elif fid == 1:
7326 
        if ftype == TType.STRUCT:
7327 
          self.ucx = UserContextException()
7328 
          self.ucx.read(iprot)
7329 
        else:
7330 
          iprot.skip(ftype)
7331 
      else:
7332 
        iprot.skip(ftype)
7333 
      iprot.readFieldEnd()
7334 
    iprot.readStructEnd()
7335 
 
7336 
  def write(self, oprot):
7337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7339 
      return
559 chandransh 7340 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7341 
    if self.success is not None:
94 ashish 7342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7343 
      oprot.writeBool(self.success)
7344 
      oprot.writeFieldEnd()
3431 rajveer 7345 
    if self.ucx is not None:
94 ashish 7346 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7347 
      self.ucx.write(oprot)
7348 
      oprot.writeFieldEnd()
7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
3431 rajveer 7352 
  def validate(self):
7353 
    return
7354 
 
7355 
 
94 ashish 7356 
  def __repr__(self):
7357 
    L = ['%s=%r' % (key, value)
7358 
      for key, value in self.__dict__.iteritems()]
7359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7360 
 
7361 
  def __eq__(self, other):
7362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7363 
 
7364 
  def __ne__(self, other):
7365 
    return not (self == other)
7366 
 
581 rajveer 7367 
class forgotPassword_args:
7368 
  """
7369 
  Attributes:
7370 
   - email
884 rajveer 7371 
   - newPassword
581 rajveer 7372 
  """
7373 
 
7374 
  thrift_spec = (
7375 
    None, # 0
7376 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7377 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7378 
  )
7379 
 
884 rajveer 7380 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7381 
    self.email = email
884 rajveer 7382 
    self.newPassword = newPassword
581 rajveer 7383 
 
7384 
  def read(self, iprot):
7385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7387 
      return
7388 
    iprot.readStructBegin()
7389 
    while True:
7390 
      (fname, ftype, fid) = iprot.readFieldBegin()
7391 
      if ftype == TType.STOP:
7392 
        break
7393 
      if fid == 1:
7394 
        if ftype == TType.STRING:
7395 
          self.email = iprot.readString();
7396 
        else:
7397 
          iprot.skip(ftype)
884 rajveer 7398 
      elif fid == 2:
7399 
        if ftype == TType.STRING:
7400 
          self.newPassword = iprot.readString();
7401 
        else:
7402 
          iprot.skip(ftype)
581 rajveer 7403 
      else:
7404 
        iprot.skip(ftype)
7405 
      iprot.readFieldEnd()
7406 
    iprot.readStructEnd()
7407 
 
7408 
  def write(self, oprot):
7409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7411 
      return
7412 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7413 
    if self.email is not None:
581 rajveer 7414 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7415 
      oprot.writeString(self.email)
7416 
      oprot.writeFieldEnd()
3431 rajveer 7417 
    if self.newPassword is not None:
884 rajveer 7418 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7419 
      oprot.writeString(self.newPassword)
7420 
      oprot.writeFieldEnd()
581 rajveer 7421 
    oprot.writeFieldStop()
7422 
    oprot.writeStructEnd()
7423 
 
3431 rajveer 7424 
  def validate(self):
7425 
    return
7426 
 
7427 
 
581 rajveer 7428 
  def __repr__(self):
7429 
    L = ['%s=%r' % (key, value)
7430 
      for key, value in self.__dict__.iteritems()]
7431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7432 
 
7433 
  def __eq__(self, other):
7434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7435 
 
7436 
  def __ne__(self, other):
7437 
    return not (self == other)
7438 
 
7439 
class forgotPassword_result:
7440 
  """
7441 
  Attributes:
7442 
   - success
7443 
   - ucx
7444 
  """
7445 
 
7446 
  thrift_spec = (
7447 
    (0, TType.BOOL, 'success', None, None, ), # 0
7448 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7449 
  )
7450 
 
7451 
  def __init__(self, success=None, ucx=None,):
7452 
    self.success = success
7453 
    self.ucx = ucx
7454 
 
7455 
  def read(self, iprot):
7456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7458 
      return
7459 
    iprot.readStructBegin()
7460 
    while True:
7461 
      (fname, ftype, fid) = iprot.readFieldBegin()
7462 
      if ftype == TType.STOP:
7463 
        break
7464 
      if fid == 0:
7465 
        if ftype == TType.BOOL:
7466 
          self.success = iprot.readBool();
7467 
        else:
7468 
          iprot.skip(ftype)
7469 
      elif fid == 1:
7470 
        if ftype == TType.STRUCT:
7471 
          self.ucx = UserContextException()
7472 
          self.ucx.read(iprot)
7473 
        else:
7474 
          iprot.skip(ftype)
7475 
      else:
7476 
        iprot.skip(ftype)
7477 
      iprot.readFieldEnd()
7478 
    iprot.readStructEnd()
7479 
 
7480 
  def write(self, oprot):
7481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7483 
      return
7484 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7485 
    if self.success is not None:
581 rajveer 7486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7487 
      oprot.writeBool(self.success)
7488 
      oprot.writeFieldEnd()
3431 rajveer 7489 
    if self.ucx is not None:
581 rajveer 7490 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7491 
      self.ucx.write(oprot)
7492 
      oprot.writeFieldEnd()
7493 
    oprot.writeFieldStop()
7494 
    oprot.writeStructEnd()
7495 
 
3431 rajveer 7496 
  def validate(self):
7497 
    return
7498 
 
7499 
 
581 rajveer 7500 
  def __repr__(self):
7501 
    L = ['%s=%r' % (key, value)
7502 
      for key, value in self.__dict__.iteritems()]
7503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7504 
 
7505 
  def __eq__(self, other):
7506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7507 
 
7508 
  def __ne__(self, other):
7509 
    return not (self == other)
7510 
 
594 rajveer 7511 
class getAllAddressesForUser_args:
7512 
  """
7513 
  Attributes:
7514 
   - userId
7515 
  """
7516 
 
7517 
  thrift_spec = (
7518 
    None, # 0
7519 
    (1, TType.I64, 'userId', None, None, ), # 1
7520 
  )
7521 
 
7522 
  def __init__(self, userId=None,):
7523 
    self.userId = userId
7524 
 
7525 
  def read(self, iprot):
7526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7528 
      return
7529 
    iprot.readStructBegin()
7530 
    while True:
7531 
      (fname, ftype, fid) = iprot.readFieldBegin()
7532 
      if ftype == TType.STOP:
7533 
        break
7534 
      if fid == 1:
7535 
        if ftype == TType.I64:
7536 
          self.userId = iprot.readI64();
7537 
        else:
7538 
          iprot.skip(ftype)
7539 
      else:
7540 
        iprot.skip(ftype)
7541 
      iprot.readFieldEnd()
7542 
    iprot.readStructEnd()
7543 
 
7544 
  def write(self, oprot):
7545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7547 
      return
7548 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7549 
    if self.userId is not None:
594 rajveer 7550 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7551 
      oprot.writeI64(self.userId)
7552 
      oprot.writeFieldEnd()
7553 
    oprot.writeFieldStop()
7554 
    oprot.writeStructEnd()
7555 
 
3431 rajveer 7556 
  def validate(self):
7557 
    return
7558 
 
7559 
 
594 rajveer 7560 
  def __repr__(self):
7561 
    L = ['%s=%r' % (key, value)
7562 
      for key, value in self.__dict__.iteritems()]
7563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7564 
 
7565 
  def __eq__(self, other):
7566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7567 
 
7568 
  def __ne__(self, other):
7569 
    return not (self == other)
7570 
 
7571 
class getAllAddressesForUser_result:
7572 
  """
7573 
  Attributes:
7574 
   - success
7575 
   - ucx
7576 
  """
7577 
 
7578 
  thrift_spec = (
7579 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7580 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7581 
  )
7582 
 
7583 
  def __init__(self, success=None, ucx=None,):
7584 
    self.success = success
7585 
    self.ucx = ucx
7586 
 
7587 
  def read(self, iprot):
7588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7590 
      return
7591 
    iprot.readStructBegin()
7592 
    while True:
7593 
      (fname, ftype, fid) = iprot.readFieldBegin()
7594 
      if ftype == TType.STOP:
7595 
        break
7596 
      if fid == 0:
7597 
        if ftype == TType.LIST:
7598 
          self.success = []
11592 amit.gupta 7599 
          (_etype100, _size97) = iprot.readListBegin()
7600 
          for _i101 in xrange(_size97):
7601 
            _elem102 = Address()
7602 
            _elem102.read(iprot)
7603 
            self.success.append(_elem102)
594 rajveer 7604 
          iprot.readListEnd()
7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      elif fid == 1:
7608 
        if ftype == TType.STRUCT:
7609 
          self.ucx = UserContextException()
7610 
          self.ucx.read(iprot)
7611 
        else:
7612 
          iprot.skip(ftype)
7613 
      else:
7614 
        iprot.skip(ftype)
7615 
      iprot.readFieldEnd()
7616 
    iprot.readStructEnd()
7617 
 
7618 
  def write(self, oprot):
7619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7621 
      return
7622 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7623 
    if self.success is not None:
594 rajveer 7624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7626 
      for iter103 in self.success:
7627 
        iter103.write(oprot)
594 rajveer 7628 
      oprot.writeListEnd()
7629 
      oprot.writeFieldEnd()
3431 rajveer 7630 
    if self.ucx is not None:
594 rajveer 7631 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7632 
      self.ucx.write(oprot)
7633 
      oprot.writeFieldEnd()
7634 
    oprot.writeFieldStop()
7635 
    oprot.writeStructEnd()
7636 
 
3431 rajveer 7637 
  def validate(self):
7638 
    return
7639 
 
7640 
 
594 rajveer 7641 
  def __repr__(self):
7642 
    L = ['%s=%r' % (key, value)
7643 
      for key, value in self.__dict__.iteritems()]
7644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7645 
 
7646 
  def __eq__(self, other):
7647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7648 
 
7649 
  def __ne__(self, other):
7650 
    return not (self == other)
7651 
 
1894 vikas 7652 
class getAddressById_args:
7653 
  """
7654 
  Attributes:
7655 
   - addressId
7656 
  """
7657 
 
7658 
  thrift_spec = (
7659 
    None, # 0
7660 
    (1, TType.I64, 'addressId', None, None, ), # 1
7661 
  )
7662 
 
7663 
  def __init__(self, addressId=None,):
7664 
    self.addressId = addressId
7665 
 
7666 
  def read(self, iprot):
7667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7669 
      return
7670 
    iprot.readStructBegin()
7671 
    while True:
7672 
      (fname, ftype, fid) = iprot.readFieldBegin()
7673 
      if ftype == TType.STOP:
7674 
        break
7675 
      if fid == 1:
7676 
        if ftype == TType.I64:
7677 
          self.addressId = iprot.readI64();
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      else:
7681 
        iprot.skip(ftype)
7682 
      iprot.readFieldEnd()
7683 
    iprot.readStructEnd()
7684 
 
7685 
  def write(self, oprot):
7686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7688 
      return
7689 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7690 
    if self.addressId is not None:
1894 vikas 7691 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7692 
      oprot.writeI64(self.addressId)
7693 
      oprot.writeFieldEnd()
7694 
    oprot.writeFieldStop()
7695 
    oprot.writeStructEnd()
7696 
 
3431 rajveer 7697 
  def validate(self):
7698 
    return
7699 
 
7700 
 
1894 vikas 7701 
  def __repr__(self):
7702 
    L = ['%s=%r' % (key, value)
7703 
      for key, value in self.__dict__.iteritems()]
7704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7705 
 
7706 
  def __eq__(self, other):
7707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7708 
 
7709 
  def __ne__(self, other):
7710 
    return not (self == other)
7711 
 
7712 
class getAddressById_result:
7713 
  """
7714 
  Attributes:
7715 
   - success
7716 
   - ucx
7717 
  """
7718 
 
7719 
  thrift_spec = (
7720 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7721 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7722 
  )
7723 
 
7724 
  def __init__(self, success=None, ucx=None,):
7725 
    self.success = success
7726 
    self.ucx = ucx
7727 
 
7728 
  def read(self, iprot):
7729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7731 
      return
7732 
    iprot.readStructBegin()
7733 
    while True:
7734 
      (fname, ftype, fid) = iprot.readFieldBegin()
7735 
      if ftype == TType.STOP:
7736 
        break
7737 
      if fid == 0:
7738 
        if ftype == TType.STRUCT:
7739 
          self.success = Address()
7740 
          self.success.read(iprot)
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      elif fid == 1:
7744 
        if ftype == TType.STRUCT:
7745 
          self.ucx = UserContextException()
7746 
          self.ucx.read(iprot)
7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      else:
7750 
        iprot.skip(ftype)
7751 
      iprot.readFieldEnd()
7752 
    iprot.readStructEnd()
7753 
 
7754 
  def write(self, oprot):
7755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7757 
      return
7758 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7759 
    if self.success is not None:
1894 vikas 7760 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7761 
      self.success.write(oprot)
7762 
      oprot.writeFieldEnd()
3431 rajveer 7763 
    if self.ucx is not None:
1894 vikas 7764 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7765 
      self.ucx.write(oprot)
7766 
      oprot.writeFieldEnd()
7767 
    oprot.writeFieldStop()
7768 
    oprot.writeStructEnd()
7769 
 
3431 rajveer 7770 
  def validate(self):
7771 
    return
7772 
 
7773 
 
1894 vikas 7774 
  def __repr__(self):
7775 
    L = ['%s=%r' % (key, value)
7776 
      for key, value in self.__dict__.iteritems()]
7777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7778 
 
7779 
  def __eq__(self, other):
7780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7781 
 
7782 
  def __ne__(self, other):
7783 
    return not (self == other)
7784 
 
594 rajveer 7785 
class getDefaultAddressId_args:
7786 
  """
7787 
  Attributes:
7788 
   - userId
7789 
  """
7790 
 
7791 
  thrift_spec = (
7792 
    None, # 0
7793 
    (1, TType.I64, 'userId', None, None, ), # 1
7794 
  )
7795 
 
7796 
  def __init__(self, userId=None,):
7797 
    self.userId = userId
7798 
 
7799 
  def read(self, iprot):
7800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7802 
      return
7803 
    iprot.readStructBegin()
7804 
    while True:
7805 
      (fname, ftype, fid) = iprot.readFieldBegin()
7806 
      if ftype == TType.STOP:
7807 
        break
7808 
      if fid == 1:
7809 
        if ftype == TType.I64:
7810 
          self.userId = iprot.readI64();
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      else:
7814 
        iprot.skip(ftype)
7815 
      iprot.readFieldEnd()
7816 
    iprot.readStructEnd()
7817 
 
7818 
  def write(self, oprot):
7819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7821 
      return
7822 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7823 
    if self.userId is not None:
594 rajveer 7824 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7825 
      oprot.writeI64(self.userId)
7826 
      oprot.writeFieldEnd()
7827 
    oprot.writeFieldStop()
7828 
    oprot.writeStructEnd()
7829 
 
3431 rajveer 7830 
  def validate(self):
7831 
    return
7832 
 
7833 
 
594 rajveer 7834 
  def __repr__(self):
7835 
    L = ['%s=%r' % (key, value)
7836 
      for key, value in self.__dict__.iteritems()]
7837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7838 
 
7839 
  def __eq__(self, other):
7840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7841 
 
7842 
  def __ne__(self, other):
7843 
    return not (self == other)
7844 
 
7845 
class getDefaultAddressId_result:
7846 
  """
7847 
  Attributes:
7848 
   - success
7849 
   - ucx
7850 
  """
7851 
 
7852 
  thrift_spec = (
7853 
    (0, TType.I64, 'success', None, None, ), # 0
7854 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7855 
  )
7856 
 
7857 
  def __init__(self, success=None, ucx=None,):
7858 
    self.success = success
7859 
    self.ucx = ucx
7860 
 
7861 
  def read(self, iprot):
7862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7864 
      return
7865 
    iprot.readStructBegin()
7866 
    while True:
7867 
      (fname, ftype, fid) = iprot.readFieldBegin()
7868 
      if ftype == TType.STOP:
7869 
        break
7870 
      if fid == 0:
7871 
        if ftype == TType.I64:
7872 
          self.success = iprot.readI64();
7873 
        else:
7874 
          iprot.skip(ftype)
7875 
      elif fid == 1:
7876 
        if ftype == TType.STRUCT:
7877 
          self.ucx = UserContextException()
7878 
          self.ucx.read(iprot)
7879 
        else:
7880 
          iprot.skip(ftype)
7881 
      else:
7882 
        iprot.skip(ftype)
7883 
      iprot.readFieldEnd()
7884 
    iprot.readStructEnd()
7885 
 
7886 
  def write(self, oprot):
7887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7889 
      return
7890 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7891 
    if self.success is not None:
594 rajveer 7892 
      oprot.writeFieldBegin('success', TType.I64, 0)
7893 
      oprot.writeI64(self.success)
7894 
      oprot.writeFieldEnd()
3431 rajveer 7895 
    if self.ucx is not None:
594 rajveer 7896 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7897 
      self.ucx.write(oprot)
7898 
      oprot.writeFieldEnd()
7899 
    oprot.writeFieldStop()
7900 
    oprot.writeStructEnd()
7901 
 
3431 rajveer 7902 
  def validate(self):
7903 
    return
7904 
 
7905 
 
594 rajveer 7906 
  def __repr__(self):
7907 
    L = ['%s=%r' % (key, value)
7908 
      for key, value in self.__dict__.iteritems()]
7909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7910 
 
7911 
  def __eq__(self, other):
7912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7913 
 
7914 
  def __ne__(self, other):
7915 
    return not (self == other)
7916 
 
785 rajveer 7917 
class getDefaultPincode_args:
7918 
  """
7919 
  Attributes:
7920 
   - userId
7921 
  """
7922 
 
7923 
  thrift_spec = (
7924 
    None, # 0
7925 
    (1, TType.I64, 'userId', None, None, ), # 1
7926 
  )
7927 
 
7928 
  def __init__(self, userId=None,):
7929 
    self.userId = userId
7930 
 
7931 
  def read(self, iprot):
7932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7934 
      return
7935 
    iprot.readStructBegin()
7936 
    while True:
7937 
      (fname, ftype, fid) = iprot.readFieldBegin()
7938 
      if ftype == TType.STOP:
7939 
        break
7940 
      if fid == 1:
7941 
        if ftype == TType.I64:
7942 
          self.userId = iprot.readI64();
7943 
        else:
7944 
          iprot.skip(ftype)
7945 
      else:
7946 
        iprot.skip(ftype)
7947 
      iprot.readFieldEnd()
7948 
    iprot.readStructEnd()
7949 
 
7950 
  def write(self, oprot):
7951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7953 
      return
7954 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7955 
    if self.userId is not None:
785 rajveer 7956 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7957 
      oprot.writeI64(self.userId)
7958 
      oprot.writeFieldEnd()
7959 
    oprot.writeFieldStop()
7960 
    oprot.writeStructEnd()
7961 
 
3431 rajveer 7962 
  def validate(self):
7963 
    return
7964 
 
7965 
 
785 rajveer 7966 
  def __repr__(self):
7967 
    L = ['%s=%r' % (key, value)
7968 
      for key, value in self.__dict__.iteritems()]
7969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7970 
 
7971 
  def __eq__(self, other):
7972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7973 
 
7974 
  def __ne__(self, other):
7975 
    return not (self == other)
7976 
 
7977 
class getDefaultPincode_result:
7978 
  """
7979 
  Attributes:
7980 
   - success
7981 
   - ucx
7982 
  """
7983 
 
7984 
  thrift_spec = (
7985 
    (0, TType.STRING, 'success', None, None, ), # 0
7986 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7987 
  )
7988 
 
7989 
  def __init__(self, success=None, ucx=None,):
7990 
    self.success = success
7991 
    self.ucx = ucx
7992 
 
7993 
  def read(self, iprot):
7994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7996 
      return
7997 
    iprot.readStructBegin()
7998 
    while True:
7999 
      (fname, ftype, fid) = iprot.readFieldBegin()
8000 
      if ftype == TType.STOP:
8001 
        break
8002 
      if fid == 0:
8003 
        if ftype == TType.STRING:
8004 
          self.success = iprot.readString();
8005 
        else:
8006 
          iprot.skip(ftype)
8007 
      elif fid == 1:
8008 
        if ftype == TType.STRUCT:
8009 
          self.ucx = UserContextException()
8010 
          self.ucx.read(iprot)
8011 
        else:
8012 
          iprot.skip(ftype)
8013 
      else:
8014 
        iprot.skip(ftype)
8015 
      iprot.readFieldEnd()
8016 
    iprot.readStructEnd()
8017 
 
8018 
  def write(self, oprot):
8019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8021 
      return
8022 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 8023 
    if self.success is not None:
785 rajveer 8024 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8025 
      oprot.writeString(self.success)
8026 
      oprot.writeFieldEnd()
3431 rajveer 8027 
    if self.ucx is not None:
785 rajveer 8028 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8029 
      self.ucx.write(oprot)
8030 
      oprot.writeFieldEnd()
8031 
    oprot.writeFieldStop()
8032 
    oprot.writeStructEnd()
8033 
 
3431 rajveer 8034 
  def validate(self):
8035 
    return
8036 
 
8037 
 
785 rajveer 8038 
  def __repr__(self):
8039 
    L = ['%s=%r' % (key, value)
8040 
      for key, value in self.__dict__.iteritems()]
8041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8042 
 
8043 
  def __eq__(self, other):
8044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8045 
 
8046 
  def __ne__(self, other):
8047 
    return not (self == other)
8048 
 
1274 varun.gupt 8049 
class saveUserCommunication_args:
8050 
  """
8051 
  Attributes:
8052 
   - userId
8053 
   - replyTo
8054 
   - communicationType
8055 
   - orderId
8056 
   - airwaybillNo
8057 
   - productName
8058 
   - subject
8059 
   - message
8060 
  """
8061 
 
8062 
  thrift_spec = (
8063 
    None, # 0
8064 
    (1, TType.I64, 'userId', None, None, ), # 1
8065 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8066 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8067 
    (4, TType.I64, 'orderId', None, None, ), # 4
8068 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8069 
    (6, TType.STRING, 'productName', None, None, ), # 6
8070 
    (7, TType.STRING, 'subject', None, None, ), # 7
8071 
    (8, TType.STRING, 'message', None, None, ), # 8
8072 
  )
8073 
 
8074 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8075 
    self.userId = userId
8076 
    self.replyTo = replyTo
8077 
    self.communicationType = communicationType
8078 
    self.orderId = orderId
8079 
    self.airwaybillNo = airwaybillNo
8080 
    self.productName = productName
8081 
    self.subject = subject
8082 
    self.message = message
8083 
 
8084 
  def read(self, iprot):
8085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8087 
      return
8088 
    iprot.readStructBegin()
8089 
    while True:
8090 
      (fname, ftype, fid) = iprot.readFieldBegin()
8091 
      if ftype == TType.STOP:
8092 
        break
8093 
      if fid == 1:
8094 
        if ftype == TType.I64:
8095 
          self.userId = iprot.readI64();
8096 
        else:
8097 
          iprot.skip(ftype)
8098 
      elif fid == 2:
8099 
        if ftype == TType.STRING:
8100 
          self.replyTo = iprot.readString();
8101 
        else:
8102 
          iprot.skip(ftype)
8103 
      elif fid == 3:
8104 
        if ftype == TType.I64:
8105 
          self.communicationType = iprot.readI64();
8106 
        else:
8107 
          iprot.skip(ftype)
8108 
      elif fid == 4:
8109 
        if ftype == TType.I64:
8110 
          self.orderId = iprot.readI64();
8111 
        else:
8112 
          iprot.skip(ftype)
8113 
      elif fid == 5:
8114 
        if ftype == TType.STRING:
8115 
          self.airwaybillNo = iprot.readString();
8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      elif fid == 6:
8119 
        if ftype == TType.STRING:
8120 
          self.productName = iprot.readString();
8121 
        else:
8122 
          iprot.skip(ftype)
8123 
      elif fid == 7:
8124 
        if ftype == TType.STRING:
8125 
          self.subject = iprot.readString();
8126 
        else:
8127 
          iprot.skip(ftype)
8128 
      elif fid == 8:
8129 
        if ftype == TType.STRING:
8130 
          self.message = iprot.readString();
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('saveUserCommunication_args')
3431 rajveer 8143 
    if self.userId is not None:
1274 varun.gupt 8144 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8145 
      oprot.writeI64(self.userId)
8146 
      oprot.writeFieldEnd()
3431 rajveer 8147 
    if self.replyTo is not None:
1274 varun.gupt 8148 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8149 
      oprot.writeString(self.replyTo)
8150 
      oprot.writeFieldEnd()
3431 rajveer 8151 
    if self.communicationType is not None:
1274 varun.gupt 8152 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8153 
      oprot.writeI64(self.communicationType)
8154 
      oprot.writeFieldEnd()
3431 rajveer 8155 
    if self.orderId is not None:
1274 varun.gupt 8156 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8157 
      oprot.writeI64(self.orderId)
8158 
      oprot.writeFieldEnd()
3431 rajveer 8159 
    if self.airwaybillNo is not None:
1274 varun.gupt 8160 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8161 
      oprot.writeString(self.airwaybillNo)
8162 
      oprot.writeFieldEnd()
3431 rajveer 8163 
    if self.productName is not None:
1274 varun.gupt 8164 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8165 
      oprot.writeString(self.productName)
8166 
      oprot.writeFieldEnd()
3431 rajveer 8167 
    if self.subject is not None:
1274 varun.gupt 8168 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8169 
      oprot.writeString(self.subject)
8170 
      oprot.writeFieldEnd()
3431 rajveer 8171 
    if self.message is not None:
1274 varun.gupt 8172 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8173 
      oprot.writeString(self.message)
8174 
      oprot.writeFieldEnd()
8175 
    oprot.writeFieldStop()
8176 
    oprot.writeStructEnd()
8177 
 
3431 rajveer 8178 
  def validate(self):
8179 
    return
8180 
 
8181 
 
1274 varun.gupt 8182 
  def __repr__(self):
8183 
    L = ['%s=%r' % (key, value)
8184 
      for key, value in self.__dict__.iteritems()]
8185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8186 
 
8187 
  def __eq__(self, other):
8188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8189 
 
8190 
  def __ne__(self, other):
8191 
    return not (self == other)
8192 
 
8193 
class saveUserCommunication_result:
8194 
  """
8195 
  Attributes:
8196 
   - success
8197 
   - ucx
8198 
  """
8199 
 
8200 
  thrift_spec = (
8201 
    (0, TType.BOOL, 'success', None, None, ), # 0
8202 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8203 
  )
8204 
 
8205 
  def __init__(self, success=None, ucx=None,):
8206 
    self.success = success
8207 
    self.ucx = ucx
8208 
 
8209 
  def read(self, iprot):
8210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8212 
      return
8213 
    iprot.readStructBegin()
8214 
    while True:
8215 
      (fname, ftype, fid) = iprot.readFieldBegin()
8216 
      if ftype == TType.STOP:
8217 
        break
8218 
      if fid == 0:
8219 
        if ftype == TType.BOOL:
8220 
          self.success = iprot.readBool();
8221 
        else:
8222 
          iprot.skip(ftype)
8223 
      elif fid == 1:
8224 
        if ftype == TType.STRUCT:
8225 
          self.ucx = UserCommunicationException()
8226 
          self.ucx.read(iprot)
8227 
        else:
8228 
          iprot.skip(ftype)
8229 
      else:
8230 
        iprot.skip(ftype)
8231 
      iprot.readFieldEnd()
8232 
    iprot.readStructEnd()
8233 
 
8234 
  def write(self, oprot):
8235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8237 
      return
8238 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8239 
    if self.success is not None:
1274 varun.gupt 8240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8241 
      oprot.writeBool(self.success)
8242 
      oprot.writeFieldEnd()
3431 rajveer 8243 
    if self.ucx is not None:
1274 varun.gupt 8244 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8245 
      self.ucx.write(oprot)
8246 
      oprot.writeFieldEnd()
8247 
    oprot.writeFieldStop()
8248 
    oprot.writeStructEnd()
8249 
 
3431 rajveer 8250 
  def validate(self):
8251 
    return
8252 
 
8253 
 
1274 varun.gupt 8254 
  def __repr__(self):
8255 
    L = ['%s=%r' % (key, value)
8256 
      for key, value in self.__dict__.iteritems()]
8257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8258 
 
8259 
  def __eq__(self, other):
8260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8261 
 
8262 
  def __ne__(self, other):
8263 
    return not (self == other)
8264 
 
1590 varun.gupt 8265 
class getUserCommunicationById_args:
8266 
  """
8267 
  Attributes:
8268 
   - id
8269 
  """
8270 
 
8271 
  thrift_spec = (
8272 
    None, # 0
8273 
    (1, TType.I64, 'id', None, None, ), # 1
8274 
  )
8275 
 
8276 
  def __init__(self, id=None,):
8277 
    self.id = id
8278 
 
8279 
  def read(self, iprot):
8280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8282 
      return
8283 
    iprot.readStructBegin()
8284 
    while True:
8285 
      (fname, ftype, fid) = iprot.readFieldBegin()
8286 
      if ftype == TType.STOP:
8287 
        break
8288 
      if fid == 1:
8289 
        if ftype == TType.I64:
8290 
          self.id = iprot.readI64();
8291 
        else:
8292 
          iprot.skip(ftype)
8293 
      else:
8294 
        iprot.skip(ftype)
8295 
      iprot.readFieldEnd()
8296 
    iprot.readStructEnd()
8297 
 
8298 
  def write(self, oprot):
8299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8301 
      return
8302 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8303 
    if self.id is not None:
1590 varun.gupt 8304 
      oprot.writeFieldBegin('id', TType.I64, 1)
8305 
      oprot.writeI64(self.id)
8306 
      oprot.writeFieldEnd()
8307 
    oprot.writeFieldStop()
8308 
    oprot.writeStructEnd()
8309 
 
3431 rajveer 8310 
  def validate(self):
8311 
    return
8312 
 
8313 
 
1590 varun.gupt 8314 
  def __repr__(self):
8315 
    L = ['%s=%r' % (key, value)
8316 
      for key, value in self.__dict__.iteritems()]
8317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8318 
 
8319 
  def __eq__(self, other):
8320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8321 
 
8322 
  def __ne__(self, other):
8323 
    return not (self == other)
8324 
 
8325 
class getUserCommunicationById_result:
8326 
  """
8327 
  Attributes:
8328 
   - success
8329 
   - ucx
8330 
  """
8331 
 
8332 
  thrift_spec = (
8333 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8334 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8335 
  )
8336 
 
8337 
  def __init__(self, success=None, ucx=None,):
8338 
    self.success = success
8339 
    self.ucx = ucx
8340 
 
8341 
  def read(self, iprot):
8342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8344 
      return
8345 
    iprot.readStructBegin()
8346 
    while True:
8347 
      (fname, ftype, fid) = iprot.readFieldBegin()
8348 
      if ftype == TType.STOP:
8349 
        break
8350 
      if fid == 0:
8351 
        if ftype == TType.STRUCT:
8352 
          self.success = UserCommunication()
8353 
          self.success.read(iprot)
8354 
        else:
8355 
          iprot.skip(ftype)
8356 
      elif fid == 1:
8357 
        if ftype == TType.STRUCT:
8358 
          self.ucx = UserCommunicationException()
8359 
          self.ucx.read(iprot)
8360 
        else:
8361 
          iprot.skip(ftype)
8362 
      else:
8363 
        iprot.skip(ftype)
8364 
      iprot.readFieldEnd()
8365 
    iprot.readStructEnd()
8366 
 
8367 
  def write(self, oprot):
8368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8370 
      return
8371 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8372 
    if self.success is not None:
1590 varun.gupt 8373 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8374 
      self.success.write(oprot)
8375 
      oprot.writeFieldEnd()
3431 rajveer 8376 
    if self.ucx is not None:
1590 varun.gupt 8377 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8378 
      self.ucx.write(oprot)
8379 
      oprot.writeFieldEnd()
8380 
    oprot.writeFieldStop()
8381 
    oprot.writeStructEnd()
8382 
 
3431 rajveer 8383 
  def validate(self):
8384 
    return
8385 
 
8386 
 
1590 varun.gupt 8387 
  def __repr__(self):
8388 
    L = ['%s=%r' % (key, value)
8389 
      for key, value in self.__dict__.iteritems()]
8390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8391 
 
8392 
  def __eq__(self, other):
8393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8394 
 
8395 
  def __ne__(self, other):
8396 
    return not (self == other)
8397 
 
8398 
class getUserCommunicationByUser_args:
8399 
  """
8400 
  Attributes:
8401 
   - userId
8402 
  """
8403 
 
8404 
  thrift_spec = (
8405 
    None, # 0
8406 
    (1, TType.I64, 'userId', None, None, ), # 1
8407 
  )
8408 
 
8409 
  def __init__(self, userId=None,):
8410 
    self.userId = userId
8411 
 
8412 
  def read(self, iprot):
8413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8415 
      return
8416 
    iprot.readStructBegin()
8417 
    while True:
8418 
      (fname, ftype, fid) = iprot.readFieldBegin()
8419 
      if ftype == TType.STOP:
8420 
        break
8421 
      if fid == 1:
8422 
        if ftype == TType.I64:
8423 
          self.userId = iprot.readI64();
8424 
        else:
8425 
          iprot.skip(ftype)
8426 
      else:
8427 
        iprot.skip(ftype)
8428 
      iprot.readFieldEnd()
8429 
    iprot.readStructEnd()
8430 
 
8431 
  def write(self, oprot):
8432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8434 
      return
8435 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8436 
    if self.userId is not None:
1590 varun.gupt 8437 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8438 
      oprot.writeI64(self.userId)
8439 
      oprot.writeFieldEnd()
8440 
    oprot.writeFieldStop()
8441 
    oprot.writeStructEnd()
8442 
 
3431 rajveer 8443 
  def validate(self):
8444 
    return
8445 
 
8446 
 
1590 varun.gupt 8447 
  def __repr__(self):
8448 
    L = ['%s=%r' % (key, value)
8449 
      for key, value in self.__dict__.iteritems()]
8450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8451 
 
8452 
  def __eq__(self, other):
8453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8454 
 
8455 
  def __ne__(self, other):
8456 
    return not (self == other)
8457 
 
8458 
class getUserCommunicationByUser_result:
8459 
  """
8460 
  Attributes:
8461 
   - success
8462 
   - ucx
8463 
  """
8464 
 
8465 
  thrift_spec = (
8466 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8467 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8468 
  )
8469 
 
8470 
  def __init__(self, success=None, ucx=None,):
8471 
    self.success = success
8472 
    self.ucx = ucx
8473 
 
8474 
  def read(self, iprot):
8475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8477 
      return
8478 
    iprot.readStructBegin()
8479 
    while True:
8480 
      (fname, ftype, fid) = iprot.readFieldBegin()
8481 
      if ftype == TType.STOP:
8482 
        break
8483 
      if fid == 0:
8484 
        if ftype == TType.LIST:
8485 
          self.success = []
11592 amit.gupta 8486 
          (_etype107, _size104) = iprot.readListBegin()
8487 
          for _i108 in xrange(_size104):
8488 
            _elem109 = UserCommunication()
8489 
            _elem109.read(iprot)
8490 
            self.success.append(_elem109)
1590 varun.gupt 8491 
          iprot.readListEnd()
8492 
        else:
8493 
          iprot.skip(ftype)
8494 
      elif fid == 1:
8495 
        if ftype == TType.STRUCT:
8496 
          self.ucx = UserCommunicationException()
8497 
          self.ucx.read(iprot)
8498 
        else:
8499 
          iprot.skip(ftype)
8500 
      else:
8501 
        iprot.skip(ftype)
8502 
      iprot.readFieldEnd()
8503 
    iprot.readStructEnd()
8504 
 
8505 
  def write(self, oprot):
8506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8508 
      return
8509 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8510 
    if self.success is not None:
1590 varun.gupt 8511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8513 
      for iter110 in self.success:
8514 
        iter110.write(oprot)
1590 varun.gupt 8515 
      oprot.writeListEnd()
8516 
      oprot.writeFieldEnd()
3431 rajveer 8517 
    if self.ucx is not None:
1590 varun.gupt 8518 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8519 
      self.ucx.write(oprot)
8520 
      oprot.writeFieldEnd()
8521 
    oprot.writeFieldStop()
8522 
    oprot.writeStructEnd()
8523 
 
3431 rajveer 8524 
  def validate(self):
8525 
    return
8526 
 
8527 
 
1590 varun.gupt 8528 
  def __repr__(self):
8529 
    L = ['%s=%r' % (key, value)
8530 
      for key, value in self.__dict__.iteritems()]
8531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8532 
 
8533 
  def __eq__(self, other):
8534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8535 
 
8536 
  def __ne__(self, other):
8537 
    return not (self == other)
8538 
 
8539 
class getAllUserCommunications_args:
8540 
 
8541 
  thrift_spec = (
8542 
  )
8543 
 
8544 
  def read(self, iprot):
8545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8547 
      return
8548 
    iprot.readStructBegin()
8549 
    while True:
8550 
      (fname, ftype, fid) = iprot.readFieldBegin()
8551 
      if ftype == TType.STOP:
8552 
        break
8553 
      else:
8554 
        iprot.skip(ftype)
8555 
      iprot.readFieldEnd()
8556 
    iprot.readStructEnd()
8557 
 
8558 
  def write(self, oprot):
8559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8561 
      return
8562 
    oprot.writeStructBegin('getAllUserCommunications_args')
8563 
    oprot.writeFieldStop()
8564 
    oprot.writeStructEnd()
8565 
 
3431 rajveer 8566 
  def validate(self):
8567 
    return
8568 
 
8569 
 
1590 varun.gupt 8570 
  def __repr__(self):
8571 
    L = ['%s=%r' % (key, value)
8572 
      for key, value in self.__dict__.iteritems()]
8573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8574 
 
8575 
  def __eq__(self, other):
8576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8577 
 
8578 
  def __ne__(self, other):
8579 
    return not (self == other)
8580 
 
8581 
class getAllUserCommunications_result:
8582 
  """
8583 
  Attributes:
8584 
   - success
8585 
   - ucx
8586 
  """
8587 
 
8588 
  thrift_spec = (
8589 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8590 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8591 
  )
8592 
 
8593 
  def __init__(self, success=None, ucx=None,):
8594 
    self.success = success
8595 
    self.ucx = ucx
8596 
 
8597 
  def read(self, iprot):
8598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8600 
      return
8601 
    iprot.readStructBegin()
8602 
    while True:
8603 
      (fname, ftype, fid) = iprot.readFieldBegin()
8604 
      if ftype == TType.STOP:
8605 
        break
8606 
      if fid == 0:
8607 
        if ftype == TType.LIST:
8608 
          self.success = []
11592 amit.gupta 8609 
          (_etype114, _size111) = iprot.readListBegin()
8610 
          for _i115 in xrange(_size111):
8611 
            _elem116 = UserCommunication()
8612 
            _elem116.read(iprot)
8613 
            self.success.append(_elem116)
1590 varun.gupt 8614 
          iprot.readListEnd()
8615 
        else:
8616 
          iprot.skip(ftype)
8617 
      elif fid == 1:
8618 
        if ftype == TType.STRUCT:
8619 
          self.ucx = UserCommunicationException()
8620 
          self.ucx.read(iprot)
8621 
        else:
8622 
          iprot.skip(ftype)
8623 
      else:
8624 
        iprot.skip(ftype)
8625 
      iprot.readFieldEnd()
8626 
    iprot.readStructEnd()
8627 
 
8628 
  def write(self, oprot):
8629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8631 
      return
8632 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8633 
    if self.success is not None:
1590 varun.gupt 8634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8636 
      for iter117 in self.success:
8637 
        iter117.write(oprot)
1590 varun.gupt 8638 
      oprot.writeListEnd()
8639 
      oprot.writeFieldEnd()
3431 rajveer 8640 
    if self.ucx is not None:
1590 varun.gupt 8641 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8642 
      self.ucx.write(oprot)
8643 
      oprot.writeFieldEnd()
8644 
    oprot.writeFieldStop()
8645 
    oprot.writeStructEnd()
8646 
 
3431 rajveer 8647 
  def validate(self):
8648 
    return
8649 
 
8650 
 
1590 varun.gupt 8651 
  def __repr__(self):
8652 
    L = ['%s=%r' % (key, value)
8653 
      for key, value in self.__dict__.iteritems()]
8654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8655 
 
8656 
  def __eq__(self, other):
8657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8658 
 
8659 
  def __ne__(self, other):
8660 
    return not (self == other)
8661 
 
5407 amar.kumar 8662 
class removeUserCommunication_args:
8663 
  """
8664 
  Attributes:
8665 
   - id
8666 
  """
8667 
 
8668 
  thrift_spec = (
8669 
    None, # 0
8670 
    (1, TType.I64, 'id', None, None, ), # 1
8671 
  )
8672 
 
8673 
  def __init__(self, id=None,):
8674 
    self.id = id
8675 
 
8676 
  def read(self, iprot):
8677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8679 
      return
8680 
    iprot.readStructBegin()
8681 
    while True:
8682 
      (fname, ftype, fid) = iprot.readFieldBegin()
8683 
      if ftype == TType.STOP:
8684 
        break
8685 
      if fid == 1:
8686 
        if ftype == TType.I64:
8687 
          self.id = iprot.readI64();
8688 
        else:
8689 
          iprot.skip(ftype)
8690 
      else:
8691 
        iprot.skip(ftype)
8692 
      iprot.readFieldEnd()
8693 
    iprot.readStructEnd()
8694 
 
8695 
  def write(self, oprot):
8696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8698 
      return
8699 
    oprot.writeStructBegin('removeUserCommunication_args')
8700 
    if self.id is not None:
8701 
      oprot.writeFieldBegin('id', TType.I64, 1)
8702 
      oprot.writeI64(self.id)
8703 
      oprot.writeFieldEnd()
8704 
    oprot.writeFieldStop()
8705 
    oprot.writeStructEnd()
8706 
 
8707 
  def validate(self):
8708 
    return
8709 
 
8710 
 
8711 
  def __repr__(self):
8712 
    L = ['%s=%r' % (key, value)
8713 
      for key, value in self.__dict__.iteritems()]
8714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8715 
 
8716 
  def __eq__(self, other):
8717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8718 
 
8719 
  def __ne__(self, other):
8720 
    return not (self == other)
8721 
 
8722 
class removeUserCommunication_result:
8723 
  """
8724 
  Attributes:
8725 
   - ucx
8726 
  """
8727 
 
8728 
  thrift_spec = (
8729 
    None, # 0
8730 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8731 
  )
8732 
 
8733 
  def __init__(self, ucx=None,):
8734 
    self.ucx = ucx
8735 
 
8736 
  def read(self, iprot):
8737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8739 
      return
8740 
    iprot.readStructBegin()
8741 
    while True:
8742 
      (fname, ftype, fid) = iprot.readFieldBegin()
8743 
      if ftype == TType.STOP:
8744 
        break
8745 
      if fid == 1:
8746 
        if ftype == TType.STRUCT:
8747 
          self.ucx = UserCommunicationException()
8748 
          self.ucx.read(iprot)
8749 
        else:
8750 
          iprot.skip(ftype)
8751 
      else:
8752 
        iprot.skip(ftype)
8753 
      iprot.readFieldEnd()
8754 
    iprot.readStructEnd()
8755 
 
8756 
  def write(self, oprot):
8757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8759 
      return
8760 
    oprot.writeStructBegin('removeUserCommunication_result')
8761 
    if self.ucx is not None:
8762 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8763 
      self.ucx.write(oprot)
8764 
      oprot.writeFieldEnd()
8765 
    oprot.writeFieldStop()
8766 
    oprot.writeStructEnd()
8767 
 
8768 
  def validate(self):
8769 
    return
8770 
 
8771 
 
8772 
  def __repr__(self):
8773 
    L = ['%s=%r' % (key, value)
8774 
      for key, value in self.__dict__.iteritems()]
8775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8776 
 
8777 
  def __eq__(self, other):
8778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8779 
 
8780 
  def __ne__(self, other):
8781 
    return not (self == other)
8782 
 
1845 vikas 8783 
class createMasterAffiliate_args:
8784 
  """
8785 
  Attributes:
8786 
   - name
1859 vikas 8787 
   - addedOn
1845 vikas 8788 
  """
8789 
 
8790 
  thrift_spec = (
8791 
    None, # 0
8792 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8793 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8794 
  )
8795 
 
1859 vikas 8796 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8797 
    self.name = name
1859 vikas 8798 
    self.addedOn = addedOn
1845 vikas 8799 
 
8800 
  def read(self, iprot):
8801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8803 
      return
8804 
    iprot.readStructBegin()
8805 
    while True:
8806 
      (fname, ftype, fid) = iprot.readFieldBegin()
8807 
      if ftype == TType.STOP:
8808 
        break
8809 
      if fid == 1:
8810 
        if ftype == TType.STRING:
8811 
          self.name = iprot.readString();
8812 
        else:
8813 
          iprot.skip(ftype)
1859 vikas 8814 
      elif fid == 2:
8815 
        if ftype == TType.I64:
8816 
          self.addedOn = iprot.readI64();
8817 
        else:
8818 
          iprot.skip(ftype)
1845 vikas 8819 
      else:
8820 
        iprot.skip(ftype)
8821 
      iprot.readFieldEnd()
8822 
    iprot.readStructEnd()
8823 
 
8824 
  def write(self, oprot):
8825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8827 
      return
8828 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8829 
    if self.name is not None:
1845 vikas 8830 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8831 
      oprot.writeString(self.name)
8832 
      oprot.writeFieldEnd()
3431 rajveer 8833 
    if self.addedOn is not None:
1859 vikas 8834 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8835 
      oprot.writeI64(self.addedOn)
8836 
      oprot.writeFieldEnd()
1845 vikas 8837 
    oprot.writeFieldStop()
8838 
    oprot.writeStructEnd()
8839 
 
3431 rajveer 8840 
  def validate(self):
8841 
    return
8842 
 
8843 
 
1845 vikas 8844 
  def __repr__(self):
8845 
    L = ['%s=%r' % (key, value)
8846 
      for key, value in self.__dict__.iteritems()]
8847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8848 
 
8849 
  def __eq__(self, other):
8850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8851 
 
8852 
  def __ne__(self, other):
8853 
    return not (self == other)
8854 
 
8855 
class createMasterAffiliate_result:
8856 
  """
8857 
  Attributes:
8858 
   - success
8859 
   - utx
8860 
  """
8861 
 
8862 
  thrift_spec = (
8863 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8864 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8865 
  )
8866 
 
8867 
  def __init__(self, success=None, utx=None,):
8868 
    self.success = success
8869 
    self.utx = utx
8870 
 
8871 
  def read(self, iprot):
8872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8874 
      return
8875 
    iprot.readStructBegin()
8876 
    while True:
8877 
      (fname, ftype, fid) = iprot.readFieldBegin()
8878 
      if ftype == TType.STOP:
8879 
        break
8880 
      if fid == 0:
8881 
        if ftype == TType.STRUCT:
8882 
          self.success = MasterAffiliate()
8883 
          self.success.read(iprot)
8884 
        else:
8885 
          iprot.skip(ftype)
8886 
      elif fid == 1:
8887 
        if ftype == TType.STRUCT:
1996 vikas 8888 
          self.utx = UserAffiliateException()
1845 vikas 8889 
          self.utx.read(iprot)
8890 
        else:
8891 
          iprot.skip(ftype)
8892 
      else:
8893 
        iprot.skip(ftype)
8894 
      iprot.readFieldEnd()
8895 
    iprot.readStructEnd()
8896 
 
8897 
  def write(self, oprot):
8898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8900 
      return
8901 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8902 
    if self.success is not None:
1845 vikas 8903 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8904 
      self.success.write(oprot)
8905 
      oprot.writeFieldEnd()
3431 rajveer 8906 
    if self.utx is not None:
1845 vikas 8907 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8908 
      self.utx.write(oprot)
8909 
      oprot.writeFieldEnd()
8910 
    oprot.writeFieldStop()
8911 
    oprot.writeStructEnd()
8912 
 
3431 rajveer 8913 
  def validate(self):
8914 
    return
8915 
 
8916 
 
1845 vikas 8917 
  def __repr__(self):
8918 
    L = ['%s=%r' % (key, value)
8919 
      for key, value in self.__dict__.iteritems()]
8920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8921 
 
8922 
  def __eq__(self, other):
8923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8924 
 
8925 
  def __ne__(self, other):
8926 
    return not (self == other)
8927 
 
1899 vikas 8928 
class getAllMasterAffiliates_args:
8929 
 
8930 
  thrift_spec = (
8931 
  )
8932 
 
8933 
  def read(self, iprot):
8934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8936 
      return
8937 
    iprot.readStructBegin()
8938 
    while True:
8939 
      (fname, ftype, fid) = iprot.readFieldBegin()
8940 
      if ftype == TType.STOP:
8941 
        break
8942 
      else:
8943 
        iprot.skip(ftype)
8944 
      iprot.readFieldEnd()
8945 
    iprot.readStructEnd()
8946 
 
8947 
  def write(self, oprot):
8948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8950 
      return
8951 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8952 
    oprot.writeFieldStop()
8953 
    oprot.writeStructEnd()
8954 
 
3431 rajveer 8955 
  def validate(self):
8956 
    return
8957 
 
8958 
 
1899 vikas 8959 
  def __repr__(self):
8960 
    L = ['%s=%r' % (key, value)
8961 
      for key, value in self.__dict__.iteritems()]
8962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8963 
 
8964 
  def __eq__(self, other):
8965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8966 
 
8967 
  def __ne__(self, other):
8968 
    return not (self == other)
8969 
 
8970 
class getAllMasterAffiliates_result:
8971 
  """
8972 
  Attributes:
8973 
   - success
8974 
   - utx
8975 
  """
8976 
 
8977 
  thrift_spec = (
8978 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8979 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8980 
  )
8981 
 
8982 
  def __init__(self, success=None, utx=None,):
8983 
    self.success = success
8984 
    self.utx = utx
8985 
 
8986 
  def read(self, iprot):
8987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8989 
      return
8990 
    iprot.readStructBegin()
8991 
    while True:
8992 
      (fname, ftype, fid) = iprot.readFieldBegin()
8993 
      if ftype == TType.STOP:
8994 
        break
8995 
      if fid == 0:
8996 
        if ftype == TType.LIST:
8997 
          self.success = []
11592 amit.gupta 8998 
          (_etype121, _size118) = iprot.readListBegin()
8999 
          for _i122 in xrange(_size118):
9000 
            _elem123 = MasterAffiliate()
9001 
            _elem123.read(iprot)
9002 
            self.success.append(_elem123)
1899 vikas 9003 
          iprot.readListEnd()
9004 
        else:
9005 
          iprot.skip(ftype)
9006 
      elif fid == 1:
9007 
        if ftype == TType.STRUCT:
1996 vikas 9008 
          self.utx = UserAffiliateException()
1899 vikas 9009 
          self.utx.read(iprot)
9010 
        else:
9011 
          iprot.skip(ftype)
9012 
      else:
9013 
        iprot.skip(ftype)
9014 
      iprot.readFieldEnd()
9015 
    iprot.readStructEnd()
9016 
 
9017 
  def write(self, oprot):
9018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9020 
      return
9021 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 9022 
    if self.success is not None:
1899 vikas 9023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9025 
      for iter124 in self.success:
9026 
        iter124.write(oprot)
1899 vikas 9027 
      oprot.writeListEnd()
9028 
      oprot.writeFieldEnd()
3431 rajveer 9029 
    if self.utx is not None:
1899 vikas 9030 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9031 
      self.utx.write(oprot)
9032 
      oprot.writeFieldEnd()
9033 
    oprot.writeFieldStop()
9034 
    oprot.writeStructEnd()
9035 
 
3431 rajveer 9036 
  def validate(self):
9037 
    return
9038 
 
9039 
 
1899 vikas 9040 
  def __repr__(self):
9041 
    L = ['%s=%r' % (key, value)
9042 
      for key, value in self.__dict__.iteritems()]
9043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9044 
 
9045 
  def __eq__(self, other):
9046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9047 
 
9048 
  def __ne__(self, other):
9049 
    return not (self == other)
9050 
 
1845 vikas 9051 
class getMasterAffiliateById_args:
9052 
  """
9053 
  Attributes:
9054 
   - id
9055 
  """
9056 
 
9057 
  thrift_spec = (
9058 
    None, # 0
9059 
    (1, TType.I64, 'id', None, None, ), # 1
9060 
  )
9061 
 
9062 
  def __init__(self, id=None,):
9063 
    self.id = id
9064 
 
9065 
  def read(self, iprot):
9066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9068 
      return
9069 
    iprot.readStructBegin()
9070 
    while True:
9071 
      (fname, ftype, fid) = iprot.readFieldBegin()
9072 
      if ftype == TType.STOP:
9073 
        break
9074 
      if fid == 1:
9075 
        if ftype == TType.I64:
9076 
          self.id = iprot.readI64();
9077 
        else:
9078 
          iprot.skip(ftype)
9079 
      else:
9080 
        iprot.skip(ftype)
9081 
      iprot.readFieldEnd()
9082 
    iprot.readStructEnd()
9083 
 
9084 
  def write(self, oprot):
9085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9087 
      return
9088 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9089 
    if self.id is not None:
1845 vikas 9090 
      oprot.writeFieldBegin('id', TType.I64, 1)
9091 
      oprot.writeI64(self.id)
9092 
      oprot.writeFieldEnd()
9093 
    oprot.writeFieldStop()
9094 
    oprot.writeStructEnd()
9095 
 
3431 rajveer 9096 
  def validate(self):
9097 
    return
9098 
 
9099 
 
1845 vikas 9100 
  def __repr__(self):
9101 
    L = ['%s=%r' % (key, value)
9102 
      for key, value in self.__dict__.iteritems()]
9103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9104 
 
9105 
  def __eq__(self, other):
9106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9107 
 
9108 
  def __ne__(self, other):
9109 
    return not (self == other)
9110 
 
9111 
class getMasterAffiliateById_result:
9112 
  """
9113 
  Attributes:
9114 
   - success
9115 
   - utx
9116 
  """
9117 
 
9118 
  thrift_spec = (
9119 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9120 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9121 
  )
9122 
 
9123 
  def __init__(self, success=None, utx=None,):
9124 
    self.success = success
9125 
    self.utx = utx
9126 
 
9127 
  def read(self, iprot):
9128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9130 
      return
9131 
    iprot.readStructBegin()
9132 
    while True:
9133 
      (fname, ftype, fid) = iprot.readFieldBegin()
9134 
      if ftype == TType.STOP:
9135 
        break
9136 
      if fid == 0:
9137 
        if ftype == TType.STRUCT:
9138 
          self.success = MasterAffiliate()
9139 
          self.success.read(iprot)
9140 
        else:
9141 
          iprot.skip(ftype)
9142 
      elif fid == 1:
9143 
        if ftype == TType.STRUCT:
1996 vikas 9144 
          self.utx = UserAffiliateException()
1845 vikas 9145 
          self.utx.read(iprot)
9146 
        else:
9147 
          iprot.skip(ftype)
9148 
      else:
9149 
        iprot.skip(ftype)
9150 
      iprot.readFieldEnd()
9151 
    iprot.readStructEnd()
9152 
 
9153 
  def write(self, oprot):
9154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9156 
      return
9157 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9158 
    if self.success is not None:
1845 vikas 9159 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9160 
      self.success.write(oprot)
9161 
      oprot.writeFieldEnd()
3431 rajveer 9162 
    if self.utx is not None:
1845 vikas 9163 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9164 
      self.utx.write(oprot)
9165 
      oprot.writeFieldEnd()
9166 
    oprot.writeFieldStop()
9167 
    oprot.writeStructEnd()
9168 
 
3431 rajveer 9169 
  def validate(self):
9170 
    return
9171 
 
9172 
 
1845 vikas 9173 
  def __repr__(self):
9174 
    L = ['%s=%r' % (key, value)
9175 
      for key, value in self.__dict__.iteritems()]
9176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9177 
 
9178 
  def __eq__(self, other):
9179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9180 
 
9181 
  def __ne__(self, other):
9182 
    return not (self == other)
9183 
 
9184 
class getMasterAffiliateByName_args:
9185 
  """
9186 
  Attributes:
9187 
   - name
9188 
  """
9189 
 
9190 
  thrift_spec = (
9191 
    None, # 0
9192 
    (1, TType.STRING, 'name', None, None, ), # 1
9193 
  )
9194 
 
9195 
  def __init__(self, name=None,):
9196 
    self.name = name
9197 
 
9198 
  def read(self, iprot):
9199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9201 
      return
9202 
    iprot.readStructBegin()
9203 
    while True:
9204 
      (fname, ftype, fid) = iprot.readFieldBegin()
9205 
      if ftype == TType.STOP:
9206 
        break
9207 
      if fid == 1:
9208 
        if ftype == TType.STRING:
9209 
          self.name = iprot.readString();
9210 
        else:
9211 
          iprot.skip(ftype)
9212 
      else:
9213 
        iprot.skip(ftype)
9214 
      iprot.readFieldEnd()
9215 
    iprot.readStructEnd()
9216 
 
9217 
  def write(self, oprot):
9218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9220 
      return
9221 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9222 
    if self.name is not None:
1845 vikas 9223 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9224 
      oprot.writeString(self.name)
9225 
      oprot.writeFieldEnd()
9226 
    oprot.writeFieldStop()
9227 
    oprot.writeStructEnd()
9228 
 
3431 rajveer 9229 
  def validate(self):
9230 
    return
9231 
 
9232 
 
1845 vikas 9233 
  def __repr__(self):
9234 
    L = ['%s=%r' % (key, value)
9235 
      for key, value in self.__dict__.iteritems()]
9236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9237 
 
9238 
  def __eq__(self, other):
9239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9240 
 
9241 
  def __ne__(self, other):
9242 
    return not (self == other)
9243 
 
9244 
class getMasterAffiliateByName_result:
9245 
  """
9246 
  Attributes:
9247 
   - success
9248 
   - utx
9249 
  """
9250 
 
9251 
  thrift_spec = (
9252 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9253 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9254 
  )
9255 
 
9256 
  def __init__(self, success=None, utx=None,):
9257 
    self.success = success
9258 
    self.utx = utx
9259 
 
9260 
  def read(self, iprot):
9261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9263 
      return
9264 
    iprot.readStructBegin()
9265 
    while True:
9266 
      (fname, ftype, fid) = iprot.readFieldBegin()
9267 
      if ftype == TType.STOP:
9268 
        break
9269 
      if fid == 0:
9270 
        if ftype == TType.STRUCT:
9271 
          self.success = MasterAffiliate()
9272 
          self.success.read(iprot)
9273 
        else:
9274 
          iprot.skip(ftype)
9275 
      elif fid == 1:
9276 
        if ftype == TType.STRUCT:
1996 vikas 9277 
          self.utx = UserAffiliateException()
1845 vikas 9278 
          self.utx.read(iprot)
9279 
        else:
9280 
          iprot.skip(ftype)
9281 
      else:
9282 
        iprot.skip(ftype)
9283 
      iprot.readFieldEnd()
9284 
    iprot.readStructEnd()
9285 
 
9286 
  def write(self, oprot):
9287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9289 
      return
9290 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9291 
    if self.success is not None:
1845 vikas 9292 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9293 
      self.success.write(oprot)
9294 
      oprot.writeFieldEnd()
3431 rajveer 9295 
    if self.utx is not None:
1845 vikas 9296 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9297 
      self.utx.write(oprot)
9298 
      oprot.writeFieldEnd()
9299 
    oprot.writeFieldStop()
9300 
    oprot.writeStructEnd()
9301 
 
3431 rajveer 9302 
  def validate(self):
9303 
    return
9304 
 
9305 
 
1845 vikas 9306 
  def __repr__(self):
9307 
    L = ['%s=%r' % (key, value)
9308 
      for key, value in self.__dict__.iteritems()]
9309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9310 
 
9311 
  def __eq__(self, other):
9312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9313 
 
9314 
  def __ne__(self, other):
9315 
    return not (self == other)
9316 
 
9317 
class createAffiliate_args:
9318 
  """
9319 
  Attributes:
9320 
   - name
9321 
   - url
9322 
   - masterAffiliateId
1859 vikas 9323 
   - addedOn
1845 vikas 9324 
  """
9325 
 
9326 
  thrift_spec = (
9327 
    None, # 0
9328 
    (1, TType.STRING, 'name', None, None, ), # 1
9329 
    (2, TType.STRING, 'url', None, None, ), # 2
9330 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9331 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9332 
  )
9333 
 
1859 vikas 9334 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9335 
    self.name = name
9336 
    self.url = url
9337 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9338 
    self.addedOn = addedOn
1845 vikas 9339 
 
9340 
  def read(self, iprot):
9341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9343 
      return
9344 
    iprot.readStructBegin()
9345 
    while True:
9346 
      (fname, ftype, fid) = iprot.readFieldBegin()
9347 
      if ftype == TType.STOP:
9348 
        break
9349 
      if fid == 1:
9350 
        if ftype == TType.STRING:
9351 
          self.name = iprot.readString();
9352 
        else:
9353 
          iprot.skip(ftype)
9354 
      elif fid == 2:
9355 
        if ftype == TType.STRING:
9356 
          self.url = iprot.readString();
9357 
        else:
9358 
          iprot.skip(ftype)
9359 
      elif fid == 3:
9360 
        if ftype == TType.I64:
9361 
          self.masterAffiliateId = iprot.readI64();
9362 
        else:
9363 
          iprot.skip(ftype)
1859 vikas 9364 
      elif fid == 4:
9365 
        if ftype == TType.I64:
9366 
          self.addedOn = iprot.readI64();
9367 
        else:
9368 
          iprot.skip(ftype)
1845 vikas 9369 
      else:
9370 
        iprot.skip(ftype)
9371 
      iprot.readFieldEnd()
9372 
    iprot.readStructEnd()
9373 
 
9374 
  def write(self, oprot):
9375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9377 
      return
9378 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9379 
    if self.name is not None:
1845 vikas 9380 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9381 
      oprot.writeString(self.name)
9382 
      oprot.writeFieldEnd()
3431 rajveer 9383 
    if self.url is not None:
1845 vikas 9384 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9385 
      oprot.writeString(self.url)
9386 
      oprot.writeFieldEnd()
3431 rajveer 9387 
    if self.masterAffiliateId is not None:
1845 vikas 9388 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9389 
      oprot.writeI64(self.masterAffiliateId)
9390 
      oprot.writeFieldEnd()
3431 rajveer 9391 
    if self.addedOn is not None:
1859 vikas 9392 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9393 
      oprot.writeI64(self.addedOn)
9394 
      oprot.writeFieldEnd()
1845 vikas 9395 
    oprot.writeFieldStop()
9396 
    oprot.writeStructEnd()
9397 
 
3431 rajveer 9398 
  def validate(self):
9399 
    return
9400 
 
9401 
 
1845 vikas 9402 
  def __repr__(self):
9403 
    L = ['%s=%r' % (key, value)
9404 
      for key, value in self.__dict__.iteritems()]
9405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9406 
 
9407 
  def __eq__(self, other):
9408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9409 
 
9410 
  def __ne__(self, other):
9411 
    return not (self == other)
9412 
 
9413 
class createAffiliate_result:
9414 
  """
9415 
  Attributes:
9416 
   - success
9417 
   - utx
9418 
  """
9419 
 
9420 
  thrift_spec = (
9421 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9422 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9423 
  )
9424 
 
9425 
  def __init__(self, success=None, utx=None,):
9426 
    self.success = success
9427 
    self.utx = utx
9428 
 
9429 
  def read(self, iprot):
9430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9432 
      return
9433 
    iprot.readStructBegin()
9434 
    while True:
9435 
      (fname, ftype, fid) = iprot.readFieldBegin()
9436 
      if ftype == TType.STOP:
9437 
        break
9438 
      if fid == 0:
9439 
        if ftype == TType.STRUCT:
9440 
          self.success = Affiliate()
9441 
          self.success.read(iprot)
9442 
        else:
9443 
          iprot.skip(ftype)
9444 
      elif fid == 1:
9445 
        if ftype == TType.STRUCT:
1996 vikas 9446 
          self.utx = UserAffiliateException()
1845 vikas 9447 
          self.utx.read(iprot)
9448 
        else:
9449 
          iprot.skip(ftype)
9450 
      else:
9451 
        iprot.skip(ftype)
9452 
      iprot.readFieldEnd()
9453 
    iprot.readStructEnd()
9454 
 
9455 
  def write(self, oprot):
9456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9458 
      return
9459 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9460 
    if self.success is not None:
1845 vikas 9461 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9462 
      self.success.write(oprot)
9463 
      oprot.writeFieldEnd()
3431 rajveer 9464 
    if self.utx is not None:
1845 vikas 9465 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9466 
      self.utx.write(oprot)
9467 
      oprot.writeFieldEnd()
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
3431 rajveer 9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
1845 vikas 9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
9486 
class getAffiliateById_args:
9487 
  """
9488 
  Attributes:
9489 
   - id
9490 
  """
9491 
 
9492 
  thrift_spec = (
9493 
    None, # 0
9494 
    (1, TType.I64, 'id', None, None, ), # 1
9495 
  )
9496 
 
9497 
  def __init__(self, id=None,):
9498 
    self.id = id
9499 
 
9500 
  def read(self, iprot):
9501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9503 
      return
9504 
    iprot.readStructBegin()
9505 
    while True:
9506 
      (fname, ftype, fid) = iprot.readFieldBegin()
9507 
      if ftype == TType.STOP:
9508 
        break
9509 
      if fid == 1:
9510 
        if ftype == TType.I64:
9511 
          self.id = iprot.readI64();
9512 
        else:
9513 
          iprot.skip(ftype)
9514 
      else:
9515 
        iprot.skip(ftype)
9516 
      iprot.readFieldEnd()
9517 
    iprot.readStructEnd()
9518 
 
9519 
  def write(self, oprot):
9520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9522 
      return
9523 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9524 
    if self.id is not None:
1845 vikas 9525 
      oprot.writeFieldBegin('id', TType.I64, 1)
9526 
      oprot.writeI64(self.id)
9527 
      oprot.writeFieldEnd()
9528 
    oprot.writeFieldStop()
9529 
    oprot.writeStructEnd()
9530 
 
3431 rajveer 9531 
  def validate(self):
9532 
    return
9533 
 
9534 
 
1845 vikas 9535 
  def __repr__(self):
9536 
    L = ['%s=%r' % (key, value)
9537 
      for key, value in self.__dict__.iteritems()]
9538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9539 
 
9540 
  def __eq__(self, other):
9541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9542 
 
9543 
  def __ne__(self, other):
9544 
    return not (self == other)
9545 
 
9546 
class getAffiliateById_result:
9547 
  """
9548 
  Attributes:
9549 
   - success
9550 
   - utx
9551 
  """
9552 
 
9553 
  thrift_spec = (
9554 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9555 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9556 
  )
9557 
 
9558 
  def __init__(self, success=None, utx=None,):
9559 
    self.success = success
9560 
    self.utx = utx
9561 
 
9562 
  def read(self, iprot):
9563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9565 
      return
9566 
    iprot.readStructBegin()
9567 
    while True:
9568 
      (fname, ftype, fid) = iprot.readFieldBegin()
9569 
      if ftype == TType.STOP:
9570 
        break
9571 
      if fid == 0:
9572 
        if ftype == TType.STRUCT:
9573 
          self.success = Affiliate()
9574 
          self.success.read(iprot)
9575 
        else:
9576 
          iprot.skip(ftype)
9577 
      elif fid == 1:
9578 
        if ftype == TType.STRUCT:
1996 vikas 9579 
          self.utx = UserAffiliateException()
1845 vikas 9580 
          self.utx.read(iprot)
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      else:
9584 
        iprot.skip(ftype)
9585 
      iprot.readFieldEnd()
9586 
    iprot.readStructEnd()
9587 
 
9588 
  def write(self, oprot):
9589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9591 
      return
9592 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9593 
    if self.success is not None:
1845 vikas 9594 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9595 
      self.success.write(oprot)
9596 
      oprot.writeFieldEnd()
3431 rajveer 9597 
    if self.utx is not None:
1845 vikas 9598 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9599 
      self.utx.write(oprot)
9600 
      oprot.writeFieldEnd()
9601 
    oprot.writeFieldStop()
9602 
    oprot.writeStructEnd()
9603 
 
3431 rajveer 9604 
  def validate(self):
9605 
    return
9606 
 
9607 
 
1845 vikas 9608 
  def __repr__(self):
9609 
    L = ['%s=%r' % (key, value)
9610 
      for key, value in self.__dict__.iteritems()]
9611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9612 
 
9613 
  def __eq__(self, other):
9614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9615 
 
9616 
  def __ne__(self, other):
9617 
    return not (self == other)
9618 
 
9619 
class getAffiliateByName_args:
9620 
  """
9621 
  Attributes:
9622 
   - name
9623 
  """
9624 
 
9625 
  thrift_spec = (
9626 
    None, # 0
9627 
    (1, TType.STRING, 'name', None, None, ), # 1
9628 
  )
9629 
 
9630 
  def __init__(self, name=None,):
9631 
    self.name = name
9632 
 
9633 
  def read(self, iprot):
9634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9636 
      return
9637 
    iprot.readStructBegin()
9638 
    while True:
9639 
      (fname, ftype, fid) = iprot.readFieldBegin()
9640 
      if ftype == TType.STOP:
9641 
        break
9642 
      if fid == 1:
9643 
        if ftype == TType.STRING:
9644 
          self.name = iprot.readString();
9645 
        else:
9646 
          iprot.skip(ftype)
9647 
      else:
9648 
        iprot.skip(ftype)
9649 
      iprot.readFieldEnd()
9650 
    iprot.readStructEnd()
9651 
 
9652 
  def write(self, oprot):
9653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9655 
      return
9656 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9657 
    if self.name is not None:
1845 vikas 9658 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9659 
      oprot.writeString(self.name)
9660 
      oprot.writeFieldEnd()
9661 
    oprot.writeFieldStop()
9662 
    oprot.writeStructEnd()
9663 
 
3431 rajveer 9664 
  def validate(self):
9665 
    return
9666 
 
9667 
 
1845 vikas 9668 
  def __repr__(self):
9669 
    L = ['%s=%r' % (key, value)
9670 
      for key, value in self.__dict__.iteritems()]
9671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9672 
 
9673 
  def __eq__(self, other):
9674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9675 
 
9676 
  def __ne__(self, other):
9677 
    return not (self == other)
9678 
 
9679 
class getAffiliateByName_result:
9680 
  """
9681 
  Attributes:
9682 
   - success
9683 
   - utx
9684 
  """
9685 
 
9686 
  thrift_spec = (
9687 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9688 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9689 
  )
9690 
 
9691 
  def __init__(self, success=None, utx=None,):
9692 
    self.success = success
9693 
    self.utx = utx
9694 
 
9695 
  def read(self, iprot):
9696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9698 
      return
9699 
    iprot.readStructBegin()
9700 
    while True:
9701 
      (fname, ftype, fid) = iprot.readFieldBegin()
9702 
      if ftype == TType.STOP:
9703 
        break
9704 
      if fid == 0:
9705 
        if ftype == TType.STRUCT:
9706 
          self.success = Affiliate()
9707 
          self.success.read(iprot)
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      elif fid == 1:
9711 
        if ftype == TType.STRUCT:
1996 vikas 9712 
          self.utx = UserAffiliateException()
1845 vikas 9713 
          self.utx.read(iprot)
9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      else:
9717 
        iprot.skip(ftype)
9718 
      iprot.readFieldEnd()
9719 
    iprot.readStructEnd()
9720 
 
9721 
  def write(self, oprot):
9722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9724 
      return
9725 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9726 
    if self.success is not None:
1845 vikas 9727 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9728 
      self.success.write(oprot)
9729 
      oprot.writeFieldEnd()
3431 rajveer 9730 
    if self.utx is not None:
1845 vikas 9731 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9732 
      self.utx.write(oprot)
9733 
      oprot.writeFieldEnd()
9734 
    oprot.writeFieldStop()
9735 
    oprot.writeStructEnd()
9736 
 
3431 rajveer 9737 
  def validate(self):
9738 
    return
9739 
 
9740 
 
1845 vikas 9741 
  def __repr__(self):
9742 
    L = ['%s=%r' % (key, value)
9743 
      for key, value in self.__dict__.iteritems()]
9744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9745 
 
9746 
  def __eq__(self, other):
9747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9748 
 
9749 
  def __ne__(self, other):
9750 
    return not (self == other)
9751 
 
1996 vikas 9752 
class getTrackerById_args:
1845 vikas 9753 
  """
9754 
  Attributes:
9755 
   - id
9756 
  """
9757 
 
9758 
  thrift_spec = (
9759 
    None, # 0
9760 
    (1, TType.I64, 'id', None, None, ), # 1
9761 
  )
9762 
 
9763 
  def __init__(self, id=None,):
9764 
    self.id = id
9765 
 
9766 
  def read(self, iprot):
9767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9769 
      return
9770 
    iprot.readStructBegin()
9771 
    while True:
9772 
      (fname, ftype, fid) = iprot.readFieldBegin()
9773 
      if ftype == TType.STOP:
9774 
        break
9775 
      if fid == 1:
9776 
        if ftype == TType.I64:
9777 
          self.id = iprot.readI64();
9778 
        else:
9779 
          iprot.skip(ftype)
9780 
      else:
9781 
        iprot.skip(ftype)
9782 
      iprot.readFieldEnd()
9783 
    iprot.readStructEnd()
9784 
 
9785 
  def write(self, oprot):
9786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9788 
      return
1996 vikas 9789 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9790 
    if self.id is not None:
1845 vikas 9791 
      oprot.writeFieldBegin('id', TType.I64, 1)
9792 
      oprot.writeI64(self.id)
9793 
      oprot.writeFieldEnd()
9794 
    oprot.writeFieldStop()
9795 
    oprot.writeStructEnd()
9796 
 
3431 rajveer 9797 
  def validate(self):
9798 
    return
9799 
 
9800 
 
1845 vikas 9801 
  def __repr__(self):
9802 
    L = ['%s=%r' % (key, value)
9803 
      for key, value in self.__dict__.iteritems()]
9804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9805 
 
9806 
  def __eq__(self, other):
9807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9808 
 
9809 
  def __ne__(self, other):
9810 
    return not (self == other)
9811 
 
9812 
class getTrackerById_result:
9813 
  """
9814 
  Attributes:
9815 
   - success
9816 
   - utx
9817 
  """
9818 
 
9819 
  thrift_spec = (
9820 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9821 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9822 
  )
9823 
 
9824 
  def __init__(self, success=None, utx=None,):
9825 
    self.success = success
9826 
    self.utx = utx
9827 
 
9828 
  def read(self, iprot):
9829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9831 
      return
9832 
    iprot.readStructBegin()
9833 
    while True:
9834 
      (fname, ftype, fid) = iprot.readFieldBegin()
9835 
      if ftype == TType.STOP:
9836 
        break
9837 
      if fid == 0:
9838 
        if ftype == TType.STRUCT:
9839 
          self.success = Tracker()
9840 
          self.success.read(iprot)
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      elif fid == 1:
9844 
        if ftype == TType.STRUCT:
1996 vikas 9845 
          self.utx = UserAffiliateException()
1845 vikas 9846 
          self.utx.read(iprot)
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
9858 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9859 
    if self.success is not None:
1845 vikas 9860 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9861 
      self.success.write(oprot)
9862 
      oprot.writeFieldEnd()
3431 rajveer 9863 
    if self.utx is not None:
1845 vikas 9864 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9865 
      self.utx.write(oprot)
9866 
      oprot.writeFieldEnd()
9867 
    oprot.writeFieldStop()
9868 
    oprot.writeStructEnd()
9869 
 
3431 rajveer 9870 
  def validate(self):
9871 
    return
9872 
 
9873 
 
1845 vikas 9874 
  def __repr__(self):
9875 
    L = ['%s=%r' % (key, value)
9876 
      for key, value in self.__dict__.iteritems()]
9877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9878 
 
9879 
  def __eq__(self, other):
9880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9881 
 
9882 
  def __ne__(self, other):
9883 
    return not (self == other)
9884 
 
1996 vikas 9885 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9886 
  """
9887 
  Attributes:
1996 vikas 9888 
   - id
1845 vikas 9889 
  """
9890 
 
9891 
  thrift_spec = (
9892 
    None, # 0
1996 vikas 9893 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9894 
  )
9895 
 
1996 vikas 9896 
  def __init__(self, id=None,):
9897 
    self.id = id
1845 vikas 9898 
 
9899 
  def read(self, iprot):
9900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9902 
      return
9903 
    iprot.readStructBegin()
9904 
    while True:
9905 
      (fname, ftype, fid) = iprot.readFieldBegin()
9906 
      if ftype == TType.STOP:
9907 
        break
9908 
      if fid == 1:
9909 
        if ftype == TType.I64:
1996 vikas 9910 
          self.id = iprot.readI64();
1845 vikas 9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      else:
9914 
        iprot.skip(ftype)
9915 
      iprot.readFieldEnd()
9916 
    iprot.readStructEnd()
9917 
 
9918 
  def write(self, oprot):
9919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9921 
      return
1996 vikas 9922 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9923 
    if self.id is not None:
1996 vikas 9924 
      oprot.writeFieldBegin('id', TType.I64, 1)
9925 
      oprot.writeI64(self.id)
1845 vikas 9926 
      oprot.writeFieldEnd()
9927 
    oprot.writeFieldStop()
9928 
    oprot.writeStructEnd()
9929 
 
3431 rajveer 9930 
  def validate(self):
9931 
    return
9932 
 
9933 
 
1845 vikas 9934 
  def __repr__(self):
9935 
    L = ['%s=%r' % (key, value)
9936 
      for key, value in self.__dict__.iteritems()]
9937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9938 
 
9939 
  def __eq__(self, other):
9940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9941 
 
9942 
  def __ne__(self, other):
9943 
    return not (self == other)
9944 
 
1996 vikas 9945 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9946 
  """
9947 
  Attributes:
9948 
   - success
9949 
   - utx
9950 
  """
9951 
 
9952 
  thrift_spec = (
1996 vikas 9953 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9954 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9955 
  )
9956 
 
9957 
  def __init__(self, success=None, utx=None,):
9958 
    self.success = success
9959 
    self.utx = utx
9960 
 
9961 
  def read(self, iprot):
9962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9964 
      return
9965 
    iprot.readStructBegin()
9966 
    while True:
9967 
      (fname, ftype, fid) = iprot.readFieldBegin()
9968 
      if ftype == TType.STOP:
9969 
        break
9970 
      if fid == 0:
9971 
        if ftype == TType.LIST:
9972 
          self.success = []
11592 amit.gupta 9973 
          (_etype128, _size125) = iprot.readListBegin()
9974 
          for _i129 in xrange(_size125):
9975 
            _elem130 = Affiliate()
9976 
            _elem130.read(iprot)
9977 
            self.success.append(_elem130)
1845 vikas 9978 
          iprot.readListEnd()
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      elif fid == 1:
9982 
        if ftype == TType.STRUCT:
1996 vikas 9983 
          self.utx = UserAffiliateException()
1845 vikas 9984 
          self.utx.read(iprot)
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
1996 vikas 9996 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9997 
    if self.success is not None:
1845 vikas 9998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10000 
      for iter131 in self.success:
10001 
        iter131.write(oprot)
1845 vikas 10002 
      oprot.writeListEnd()
10003 
      oprot.writeFieldEnd()
3431 rajveer 10004 
    if self.utx is not None:
1845 vikas 10005 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10006 
      self.utx.write(oprot)
10007 
      oprot.writeFieldEnd()
10008 
    oprot.writeFieldStop()
10009 
    oprot.writeStructEnd()
10010 
 
3431 rajveer 10011 
  def validate(self):
10012 
    return
10013 
 
10014 
 
1845 vikas 10015 
  def __repr__(self):
10016 
    L = ['%s=%r' % (key, value)
10017 
      for key, value in self.__dict__.iteritems()]
10018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10019 
 
10020 
  def __eq__(self, other):
10021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10022 
 
10023 
  def __ne__(self, other):
10024 
    return not (self == other)
10025 
 
10026 
class addTrackLog_args:
10027 
  """
10028 
  Attributes:
1996 vikas 10029 
   - affiliateId
1845 vikas 10030 
   - userId
10031 
   - event
10032 
   - url
10033 
   - data
1859 vikas 10034 
   - addedOn
1845 vikas 10035 
  """
10036 
 
10037 
  thrift_spec = (
10038 
    None, # 0
1996 vikas 10039 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 10040 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 10041 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 10042 
    (4, TType.STRING, 'url', None, None, ), # 4
10043 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 10044 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 10045 
  )
10046 
 
1996 vikas 10047 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
10048 
    self.affiliateId = affiliateId
1845 vikas 10049 
    self.userId = userId
10050 
    self.event = event
10051 
    self.url = url
10052 
    self.data = data
1859 vikas 10053 
    self.addedOn = addedOn
1845 vikas 10054 
 
10055 
  def read(self, iprot):
10056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10058 
      return
10059 
    iprot.readStructBegin()
10060 
    while True:
10061 
      (fname, ftype, fid) = iprot.readFieldBegin()
10062 
      if ftype == TType.STOP:
10063 
        break
10064 
      if fid == 1:
10065 
        if ftype == TType.I64:
1996 vikas 10066 
          self.affiliateId = iprot.readI64();
1845 vikas 10067 
        else:
10068 
          iprot.skip(ftype)
10069 
      elif fid == 2:
10070 
        if ftype == TType.I64:
10071 
          self.userId = iprot.readI64();
10072 
        else:
10073 
          iprot.skip(ftype)
10074 
      elif fid == 3:
3378 vikas 10075 
        if ftype == TType.I32:
10076 
          self.event = iprot.readI32();
1845 vikas 10077 
        else:
10078 
          iprot.skip(ftype)
10079 
      elif fid == 4:
10080 
        if ftype == TType.STRING:
10081 
          self.url = iprot.readString();
10082 
        else:
10083 
          iprot.skip(ftype)
10084 
      elif fid == 5:
10085 
        if ftype == TType.STRING:
10086 
          self.data = iprot.readString();
10087 
        else:
10088 
          iprot.skip(ftype)
1859 vikas 10089 
      elif fid == 6:
10090 
        if ftype == TType.I64:
10091 
          self.addedOn = iprot.readI64();
10092 
        else:
10093 
          iprot.skip(ftype)
1845 vikas 10094 
      else:
10095 
        iprot.skip(ftype)
10096 
      iprot.readFieldEnd()
10097 
    iprot.readStructEnd()
10098 
 
10099 
  def write(self, oprot):
10100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10102 
      return
10103 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10104 
    if self.affiliateId is not None:
1996 vikas 10105 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10106 
      oprot.writeI64(self.affiliateId)
1845 vikas 10107 
      oprot.writeFieldEnd()
3431 rajveer 10108 
    if self.userId is not None:
1845 vikas 10109 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10110 
      oprot.writeI64(self.userId)
10111 
      oprot.writeFieldEnd()
3431 rajveer 10112 
    if self.event is not None:
3378 vikas 10113 
      oprot.writeFieldBegin('event', TType.I32, 3)
10114 
      oprot.writeI32(self.event)
1845 vikas 10115 
      oprot.writeFieldEnd()
3431 rajveer 10116 
    if self.url is not None:
1845 vikas 10117 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10118 
      oprot.writeString(self.url)
10119 
      oprot.writeFieldEnd()
3431 rajveer 10120 
    if self.data is not None:
1845 vikas 10121 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10122 
      oprot.writeString(self.data)
10123 
      oprot.writeFieldEnd()
3431 rajveer 10124 
    if self.addedOn is not None:
1859 vikas 10125 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10126 
      oprot.writeI64(self.addedOn)
10127 
      oprot.writeFieldEnd()
1845 vikas 10128 
    oprot.writeFieldStop()
10129 
    oprot.writeStructEnd()
10130 
 
3431 rajveer 10131 
  def validate(self):
10132 
    return
10133 
 
10134 
 
1845 vikas 10135 
  def __repr__(self):
10136 
    L = ['%s=%r' % (key, value)
10137 
      for key, value in self.__dict__.iteritems()]
10138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10139 
 
10140 
  def __eq__(self, other):
10141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10142 
 
10143 
  def __ne__(self, other):
10144 
    return not (self == other)
10145 
 
10146 
class addTrackLog_result:
10147 
  """
10148 
  Attributes:
10149 
   - success
10150 
   - utx
10151 
  """
10152 
 
10153 
  thrift_spec = (
10154 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10155 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10156 
  )
10157 
 
10158 
  def __init__(self, success=None, utx=None,):
10159 
    self.success = success
10160 
    self.utx = utx
10161 
 
10162 
  def read(self, iprot):
10163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10165 
      return
10166 
    iprot.readStructBegin()
10167 
    while True:
10168 
      (fname, ftype, fid) = iprot.readFieldBegin()
10169 
      if ftype == TType.STOP:
10170 
        break
10171 
      if fid == 0:
10172 
        if ftype == TType.I64:
10173 
          self.success = iprot.readI64();
10174 
        else:
10175 
          iprot.skip(ftype)
10176 
      elif fid == 1:
10177 
        if ftype == TType.STRUCT:
1996 vikas 10178 
          self.utx = UserAffiliateException()
1845 vikas 10179 
          self.utx.read(iprot)
10180 
        else:
10181 
          iprot.skip(ftype)
10182 
      else:
10183 
        iprot.skip(ftype)
10184 
      iprot.readFieldEnd()
10185 
    iprot.readStructEnd()
10186 
 
10187 
  def write(self, oprot):
10188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10190 
      return
10191 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10192 
    if self.success is not None:
1845 vikas 10193 
      oprot.writeFieldBegin('success', TType.I64, 0)
10194 
      oprot.writeI64(self.success)
10195 
      oprot.writeFieldEnd()
3431 rajveer 10196 
    if self.utx is not None:
1845 vikas 10197 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10198 
      self.utx.write(oprot)
10199 
      oprot.writeFieldEnd()
10200 
    oprot.writeFieldStop()
10201 
    oprot.writeStructEnd()
10202 
 
3431 rajveer 10203 
  def validate(self):
10204 
    return
10205 
 
10206 
 
1845 vikas 10207 
  def __repr__(self):
10208 
    L = ['%s=%r' % (key, value)
10209 
      for key, value in self.__dict__.iteritems()]
10210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10211 
 
10212 
  def __eq__(self, other):
10213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10214 
 
10215 
  def __ne__(self, other):
10216 
    return not (self == other)
10217 
 
10218 
class getTrackLogById_args:
10219 
  """
10220 
  Attributes:
10221 
   - id
10222 
  """
10223 
 
10224 
  thrift_spec = (
10225 
    None, # 0
10226 
    (1, TType.I64, 'id', None, None, ), # 1
10227 
  )
10228 
 
10229 
  def __init__(self, id=None,):
10230 
    self.id = id
10231 
 
10232 
  def read(self, iprot):
10233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10235 
      return
10236 
    iprot.readStructBegin()
10237 
    while True:
10238 
      (fname, ftype, fid) = iprot.readFieldBegin()
10239 
      if ftype == TType.STOP:
10240 
        break
10241 
      if fid == 1:
10242 
        if ftype == TType.I64:
10243 
          self.id = iprot.readI64();
10244 
        else:
10245 
          iprot.skip(ftype)
10246 
      else:
10247 
        iprot.skip(ftype)
10248 
      iprot.readFieldEnd()
10249 
    iprot.readStructEnd()
10250 
 
10251 
  def write(self, oprot):
10252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10254 
      return
10255 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10256 
    if self.id is not None:
1845 vikas 10257 
      oprot.writeFieldBegin('id', TType.I64, 1)
10258 
      oprot.writeI64(self.id)
10259 
      oprot.writeFieldEnd()
10260 
    oprot.writeFieldStop()
10261 
    oprot.writeStructEnd()
10262 
 
3431 rajveer 10263 
  def validate(self):
10264 
    return
10265 
 
10266 
 
1845 vikas 10267 
  def __repr__(self):
10268 
    L = ['%s=%r' % (key, value)
10269 
      for key, value in self.__dict__.iteritems()]
10270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10271 
 
10272 
  def __eq__(self, other):
10273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10274 
 
10275 
  def __ne__(self, other):
10276 
    return not (self == other)
10277 
 
10278 
class getTrackLogById_result:
10279 
  """
10280 
  Attributes:
10281 
   - success
10282 
   - utx
10283 
  """
10284 
 
10285 
  thrift_spec = (
10286 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10287 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10288 
  )
10289 
 
10290 
  def __init__(self, success=None, utx=None,):
10291 
    self.success = success
10292 
    self.utx = utx
10293 
 
10294 
  def read(self, iprot):
10295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10297 
      return
10298 
    iprot.readStructBegin()
10299 
    while True:
10300 
      (fname, ftype, fid) = iprot.readFieldBegin()
10301 
      if ftype == TType.STOP:
10302 
        break
10303 
      if fid == 0:
10304 
        if ftype == TType.STRUCT:
10305 
          self.success = TrackLog()
10306 
          self.success.read(iprot)
10307 
        else:
10308 
          iprot.skip(ftype)
10309 
      elif fid == 1:
10310 
        if ftype == TType.STRUCT:
1996 vikas 10311 
          self.utx = UserAffiliateException()
1845 vikas 10312 
          self.utx.read(iprot)
10313 
        else:
10314 
          iprot.skip(ftype)
10315 
      else:
10316 
        iprot.skip(ftype)
10317 
      iprot.readFieldEnd()
10318 
    iprot.readStructEnd()
10319 
 
10320 
  def write(self, oprot):
10321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10323 
      return
10324 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10325 
    if self.success is not None:
1845 vikas 10326 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10327 
      self.success.write(oprot)
10328 
      oprot.writeFieldEnd()
3431 rajveer 10329 
    if self.utx is not None:
1845 vikas 10330 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10331 
      self.utx.write(oprot)
10332 
      oprot.writeFieldEnd()
10333 
    oprot.writeFieldStop()
10334 
    oprot.writeStructEnd()
10335 
 
3431 rajveer 10336 
  def validate(self):
10337 
    return
10338 
 
10339 
 
1845 vikas 10340 
  def __repr__(self):
10341 
    L = ['%s=%r' % (key, value)
10342 
      for key, value in self.__dict__.iteritems()]
10343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10344 
 
10345 
  def __eq__(self, other):
10346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10347 
 
10348 
  def __ne__(self, other):
10349 
    return not (self == other)
10350 
 
1996 vikas 10351 
class getTrackLogsByAffiliate_args:
1845 vikas 10352 
  """
10353 
  Attributes:
1996 vikas 10354 
   - affiliateId
3293 vikas 10355 
   - startDate
10356 
   - endDate
1845 vikas 10357 
  """
10358 
 
10359 
  thrift_spec = (
10360 
    None, # 0
1996 vikas 10361 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10362 
    (2, TType.I64, 'startDate', None, None, ), # 2
10363 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10364 
  )
10365 
 
3293 vikas 10366 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10367 
    self.affiliateId = affiliateId
3293 vikas 10368 
    self.startDate = startDate
10369 
    self.endDate = endDate
1845 vikas 10370 
 
10371 
  def read(self, iprot):
10372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10374 
      return
10375 
    iprot.readStructBegin()
10376 
    while True:
10377 
      (fname, ftype, fid) = iprot.readFieldBegin()
10378 
      if ftype == TType.STOP:
10379 
        break
10380 
      if fid == 1:
10381 
        if ftype == TType.I64:
1996 vikas 10382 
          self.affiliateId = iprot.readI64();
1845 vikas 10383 
        else:
10384 
          iprot.skip(ftype)
3293 vikas 10385 
      elif fid == 2:
10386 
        if ftype == TType.I64:
10387 
          self.startDate = iprot.readI64();
10388 
        else:
10389 
          iprot.skip(ftype)
10390 
      elif fid == 3:
10391 
        if ftype == TType.I64:
10392 
          self.endDate = iprot.readI64();
10393 
        else:
10394 
          iprot.skip(ftype)
1845 vikas 10395 
      else:
10396 
        iprot.skip(ftype)
10397 
      iprot.readFieldEnd()
10398 
    iprot.readStructEnd()
10399 
 
10400 
  def write(self, oprot):
10401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10403 
      return
1996 vikas 10404 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10405 
    if self.affiliateId is not None:
1996 vikas 10406 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10407 
      oprot.writeI64(self.affiliateId)
1845 vikas 10408 
      oprot.writeFieldEnd()
3431 rajveer 10409 
    if self.startDate is not None:
3293 vikas 10410 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10411 
      oprot.writeI64(self.startDate)
10412 
      oprot.writeFieldEnd()
3431 rajveer 10413 
    if self.endDate is not None:
3293 vikas 10414 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10415 
      oprot.writeI64(self.endDate)
10416 
      oprot.writeFieldEnd()
1845 vikas 10417 
    oprot.writeFieldStop()
10418 
    oprot.writeStructEnd()
10419 
 
3431 rajveer 10420 
  def validate(self):
10421 
    return
10422 
 
10423 
 
1845 vikas 10424 
  def __repr__(self):
10425 
    L = ['%s=%r' % (key, value)
10426 
      for key, value in self.__dict__.iteritems()]
10427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10428 
 
10429 
  def __eq__(self, other):
10430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10431 
 
10432 
  def __ne__(self, other):
10433 
    return not (self == other)
10434 
 
1996 vikas 10435 
class getTrackLogsByAffiliate_result:
1845 vikas 10436 
  """
10437 
  Attributes:
10438 
   - success
10439 
   - utx
10440 
  """
10441 
 
10442 
  thrift_spec = (
10443 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10444 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10445 
  )
10446 
 
10447 
  def __init__(self, success=None, utx=None,):
10448 
    self.success = success
10449 
    self.utx = utx
10450 
 
10451 
  def read(self, iprot):
10452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10454 
      return
10455 
    iprot.readStructBegin()
10456 
    while True:
10457 
      (fname, ftype, fid) = iprot.readFieldBegin()
10458 
      if ftype == TType.STOP:
10459 
        break
10460 
      if fid == 0:
10461 
        if ftype == TType.LIST:
10462 
          self.success = []
11592 amit.gupta 10463 
          (_etype135, _size132) = iprot.readListBegin()
10464 
          for _i136 in xrange(_size132):
10465 
            _elem137 = TrackLog()
10466 
            _elem137.read(iprot)
10467 
            self.success.append(_elem137)
1845 vikas 10468 
          iprot.readListEnd()
10469 
        else:
10470 
          iprot.skip(ftype)
10471 
      elif fid == 1:
10472 
        if ftype == TType.STRUCT:
1996 vikas 10473 
          self.utx = UserAffiliateException()
1845 vikas 10474 
          self.utx.read(iprot)
10475 
        else:
10476 
          iprot.skip(ftype)
10477 
      else:
10478 
        iprot.skip(ftype)
10479 
      iprot.readFieldEnd()
10480 
    iprot.readStructEnd()
10481 
 
10482 
  def write(self, oprot):
10483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10485 
      return
1996 vikas 10486 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10487 
    if self.success is not None:
1845 vikas 10488 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10489 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10490 
      for iter138 in self.success:
10491 
        iter138.write(oprot)
1845 vikas 10492 
      oprot.writeListEnd()
10493 
      oprot.writeFieldEnd()
3431 rajveer 10494 
    if self.utx is not None:
1845 vikas 10495 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10496 
      self.utx.write(oprot)
10497 
      oprot.writeFieldEnd()
10498 
    oprot.writeFieldStop()
10499 
    oprot.writeStructEnd()
10500 
 
3431 rajveer 10501 
  def validate(self):
10502 
    return
10503 
 
10504 
 
1845 vikas 10505 
  def __repr__(self):
10506 
    L = ['%s=%r' % (key, value)
10507 
      for key, value in self.__dict__.iteritems()]
10508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10509 
 
10510 
  def __eq__(self, other):
10511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10512 
 
10513 
  def __ne__(self, other):
10514 
    return not (self == other)
10515 
 
10516 
class getTrackLogsByUser_args:
10517 
  """
10518 
  Attributes:
10519 
   - userId
10520 
  """
10521 
 
10522 
  thrift_spec = (
10523 
    None, # 0
10524 
    (1, TType.I64, 'userId', None, None, ), # 1
10525 
  )
10526 
 
10527 
  def __init__(self, userId=None,):
10528 
    self.userId = userId
10529 
 
10530 
  def read(self, iprot):
10531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10533 
      return
10534 
    iprot.readStructBegin()
10535 
    while True:
10536 
      (fname, ftype, fid) = iprot.readFieldBegin()
10537 
      if ftype == TType.STOP:
10538 
        break
10539 
      if fid == 1:
10540 
        if ftype == TType.I64:
10541 
          self.userId = iprot.readI64();
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      else:
10545 
        iprot.skip(ftype)
10546 
      iprot.readFieldEnd()
10547 
    iprot.readStructEnd()
10548 
 
10549 
  def write(self, oprot):
10550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10552 
      return
10553 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10554 
    if self.userId is not None:
1845 vikas 10555 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10556 
      oprot.writeI64(self.userId)
10557 
      oprot.writeFieldEnd()
10558 
    oprot.writeFieldStop()
10559 
    oprot.writeStructEnd()
10560 
 
3431 rajveer 10561 
  def validate(self):
10562 
    return
10563 
 
10564 
 
1845 vikas 10565 
  def __repr__(self):
10566 
    L = ['%s=%r' % (key, value)
10567 
      for key, value in self.__dict__.iteritems()]
10568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10569 
 
10570 
  def __eq__(self, other):
10571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10572 
 
10573 
  def __ne__(self, other):
10574 
    return not (self == other)
10575 
 
10576 
class getTrackLogsByUser_result:
10577 
  """
10578 
  Attributes:
10579 
   - success
10580 
   - utx
10581 
  """
10582 
 
10583 
  thrift_spec = (
10584 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10585 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10586 
  )
10587 
 
10588 
  def __init__(self, success=None, utx=None,):
10589 
    self.success = success
10590 
    self.utx = utx
10591 
 
10592 
  def read(self, iprot):
10593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10595 
      return
10596 
    iprot.readStructBegin()
10597 
    while True:
10598 
      (fname, ftype, fid) = iprot.readFieldBegin()
10599 
      if ftype == TType.STOP:
10600 
        break
10601 
      if fid == 0:
10602 
        if ftype == TType.LIST:
10603 
          self.success = []
11592 amit.gupta 10604 
          (_etype142, _size139) = iprot.readListBegin()
10605 
          for _i143 in xrange(_size139):
10606 
            _elem144 = TrackLog()
10607 
            _elem144.read(iprot)
10608 
            self.success.append(_elem144)
1845 vikas 10609 
          iprot.readListEnd()
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      elif fid == 1:
10613 
        if ftype == TType.STRUCT:
1996 vikas 10614 
          self.utx = UserAffiliateException()
1845 vikas 10615 
          self.utx.read(iprot)
10616 
        else:
10617 
          iprot.skip(ftype)
10618 
      else:
10619 
        iprot.skip(ftype)
10620 
      iprot.readFieldEnd()
10621 
    iprot.readStructEnd()
10622 
 
10623 
  def write(self, oprot):
10624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10626 
      return
10627 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10628 
    if self.success is not None:
1845 vikas 10629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10630 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10631 
      for iter145 in self.success:
10632 
        iter145.write(oprot)
1845 vikas 10633 
      oprot.writeListEnd()
10634 
      oprot.writeFieldEnd()
3431 rajveer 10635 
    if self.utx is not None:
1845 vikas 10636 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10637 
      self.utx.write(oprot)
10638 
      oprot.writeFieldEnd()
10639 
    oprot.writeFieldStop()
10640 
    oprot.writeStructEnd()
10641 
 
3431 rajveer 10642 
  def validate(self):
10643 
    return
10644 
 
10645 
 
1845 vikas 10646 
  def __repr__(self):
10647 
    L = ['%s=%r' % (key, value)
10648 
      for key, value in self.__dict__.iteritems()]
10649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10650 
 
10651 
  def __eq__(self, other):
10652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10653 
 
10654 
  def __ne__(self, other):
10655 
    return not (self == other)
10656 
 
10657 
class getTrackLogs_args:
10658 
  """
10659 
  Attributes:
10660 
   - userId
10661 
   - event
10662 
   - url
10663 
  """
10664 
 
10665 
  thrift_spec = (
10666 
    None, # 0
1996 vikas 10667 
    (1, TType.I64, 'userId', None, None, ), # 1
10668 
    (2, TType.STRING, 'event', None, None, ), # 2
10669 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10670 
  )
10671 
 
1996 vikas 10672 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10673 
    self.userId = userId
10674 
    self.event = event
10675 
    self.url = url
10676 
 
10677 
  def read(self, iprot):
10678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10680 
      return
10681 
    iprot.readStructBegin()
10682 
    while True:
10683 
      (fname, ftype, fid) = iprot.readFieldBegin()
10684 
      if ftype == TType.STOP:
10685 
        break
10686 
      if fid == 1:
10687 
        if ftype == TType.I64:
1996 vikas 10688 
          self.userId = iprot.readI64();
1845 vikas 10689 
        else:
10690 
          iprot.skip(ftype)
10691 
      elif fid == 2:
10692 
        if ftype == TType.STRING:
10693 
          self.event = iprot.readString();
10694 
        else:
10695 
          iprot.skip(ftype)
1996 vikas 10696 
      elif fid == 3:
1845 vikas 10697 
        if ftype == TType.STRING:
10698 
          self.url = iprot.readString();
10699 
        else:
10700 
          iprot.skip(ftype)
10701 
      else:
10702 
        iprot.skip(ftype)
10703 
      iprot.readFieldEnd()
10704 
    iprot.readStructEnd()
10705 
 
10706 
  def write(self, oprot):
10707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10709 
      return
10710 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10711 
    if self.userId is not None:
1996 vikas 10712 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10713 
      oprot.writeI64(self.userId)
10714 
      oprot.writeFieldEnd()
3431 rajveer 10715 
    if self.event is not None:
1996 vikas 10716 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10717 
      oprot.writeString(self.event)
10718 
      oprot.writeFieldEnd()
3431 rajveer 10719 
    if self.url is not None:
1996 vikas 10720 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10721 
      oprot.writeString(self.url)
10722 
      oprot.writeFieldEnd()
10723 
    oprot.writeFieldStop()
10724 
    oprot.writeStructEnd()
10725 
 
3431 rajveer 10726 
  def validate(self):
10727 
    return
10728 
 
10729 
 
1845 vikas 10730 
  def __repr__(self):
10731 
    L = ['%s=%r' % (key, value)
10732 
      for key, value in self.__dict__.iteritems()]
10733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10734 
 
10735 
  def __eq__(self, other):
10736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10737 
 
10738 
  def __ne__(self, other):
10739 
    return not (self == other)
10740 
 
10741 
class getTrackLogs_result:
10742 
  """
10743 
  Attributes:
10744 
   - success
10745 
   - utx
10746 
  """
10747 
 
10748 
  thrift_spec = (
10749 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10750 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10751 
  )
10752 
 
10753 
  def __init__(self, success=None, utx=None,):
10754 
    self.success = success
10755 
    self.utx = utx
10756 
 
10757 
  def read(self, iprot):
10758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10760 
      return
10761 
    iprot.readStructBegin()
10762 
    while True:
10763 
      (fname, ftype, fid) = iprot.readFieldBegin()
10764 
      if ftype == TType.STOP:
10765 
        break
10766 
      if fid == 0:
10767 
        if ftype == TType.LIST:
10768 
          self.success = []
11592 amit.gupta 10769 
          (_etype149, _size146) = iprot.readListBegin()
10770 
          for _i150 in xrange(_size146):
10771 
            _elem151 = TrackLog()
10772 
            _elem151.read(iprot)
10773 
            self.success.append(_elem151)
1845 vikas 10774 
          iprot.readListEnd()
10775 
        else:
10776 
          iprot.skip(ftype)
10777 
      elif fid == 1:
10778 
        if ftype == TType.STRUCT:
1996 vikas 10779 
          self.utx = UserAffiliateException()
1845 vikas 10780 
          self.utx.read(iprot)
10781 
        else:
10782 
          iprot.skip(ftype)
10783 
      else:
10784 
        iprot.skip(ftype)
10785 
      iprot.readFieldEnd()
10786 
    iprot.readStructEnd()
10787 
 
10788 
  def write(self, oprot):
10789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10791 
      return
10792 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10793 
    if self.success is not None:
1845 vikas 10794 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10795 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10796 
      for iter152 in self.success:
10797 
        iter152.write(oprot)
1845 vikas 10798 
      oprot.writeListEnd()
10799 
      oprot.writeFieldEnd()
3431 rajveer 10800 
    if self.utx is not None:
1845 vikas 10801 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10802 
      self.utx.write(oprot)
10803 
      oprot.writeFieldEnd()
10804 
    oprot.writeFieldStop()
10805 
    oprot.writeStructEnd()
10806 
 
3431 rajveer 10807 
  def validate(self):
10808 
    return
10809 
 
10810 
 
1845 vikas 10811 
  def __repr__(self):
10812 
    L = ['%s=%r' % (key, value)
10813 
      for key, value in self.__dict__.iteritems()]
10814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10815 
 
10816 
  def __eq__(self, other):
10817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10818 
 
10819 
  def __ne__(self, other):
10820 
    return not (self == other)
10821 
 
559 chandransh 10822 
class getCurrentCart_args:
94 ashish 10823 
  """
10824 
  Attributes:
559 chandransh 10825 
   - userId
10826 
  """
10827 
 
10828 
  thrift_spec = (
10829 
    None, # 0
10830 
    (1, TType.I64, 'userId', None, None, ), # 1
10831 
  )
10832 
 
10833 
  def __init__(self, userId=None,):
10834 
    self.userId = userId
10835 
 
10836 
  def read(self, iprot):
10837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10839 
      return
10840 
    iprot.readStructBegin()
10841 
    while True:
10842 
      (fname, ftype, fid) = iprot.readFieldBegin()
10843 
      if ftype == TType.STOP:
10844 
        break
10845 
      if fid == 1:
10846 
        if ftype == TType.I64:
10847 
          self.userId = iprot.readI64();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
10859 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10860 
    if self.userId is not None:
559 chandransh 10861 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10862 
      oprot.writeI64(self.userId)
10863 
      oprot.writeFieldEnd()
10864 
    oprot.writeFieldStop()
10865 
    oprot.writeStructEnd()
10866 
 
3431 rajveer 10867 
  def validate(self):
10868 
    return
10869 
 
10870 
 
559 chandransh 10871 
  def __repr__(self):
10872 
    L = ['%s=%r' % (key, value)
10873 
      for key, value in self.__dict__.iteritems()]
10874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10875 
 
10876 
  def __eq__(self, other):
10877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10878 
 
10879 
  def __ne__(self, other):
10880 
    return not (self == other)
10881 
 
10882 
class getCurrentCart_result:
10883 
  """
10884 
  Attributes:
94 ashish 10885 
   - success
559 chandransh 10886 
   - scx
94 ashish 10887 
  """
10888 
 
10889 
  thrift_spec = (
559 chandransh 10890 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10891 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10892 
  )
10893 
 
559 chandransh 10894 
  def __init__(self, success=None, scx=None,):
94 ashish 10895 
    self.success = success
559 chandransh 10896 
    self.scx = scx
94 ashish 10897 
 
10898 
  def read(self, iprot):
10899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10901 
      return
10902 
    iprot.readStructBegin()
10903 
    while True:
10904 
      (fname, ftype, fid) = iprot.readFieldBegin()
10905 
      if ftype == TType.STOP:
10906 
        break
10907 
      if fid == 0:
559 chandransh 10908 
        if ftype == TType.STRUCT:
10909 
          self.success = Cart()
10910 
          self.success.read(iprot)
94 ashish 10911 
        else:
10912 
          iprot.skip(ftype)
10913 
      elif fid == 1:
10914 
        if ftype == TType.STRUCT:
559 chandransh 10915 
          self.scx = ShoppingCartException()
10916 
          self.scx.read(iprot)
94 ashish 10917 
        else:
10918 
          iprot.skip(ftype)
10919 
      else:
10920 
        iprot.skip(ftype)
10921 
      iprot.readFieldEnd()
10922 
    iprot.readStructEnd()
10923 
 
10924 
  def write(self, oprot):
10925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10927 
      return
559 chandransh 10928 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10929 
    if self.success is not None:
559 chandransh 10930 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10931 
      self.success.write(oprot)
94 ashish 10932 
      oprot.writeFieldEnd()
3431 rajveer 10933 
    if self.scx is not None:
559 chandransh 10934 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10935 
      self.scx.write(oprot)
94 ashish 10936 
      oprot.writeFieldEnd()
10937 
    oprot.writeFieldStop()
10938 
    oprot.writeStructEnd()
10939 
 
3431 rajveer 10940 
  def validate(self):
10941 
    return
10942 
 
10943 
 
94 ashish 10944 
  def __repr__(self):
10945 
    L = ['%s=%r' % (key, value)
10946 
      for key, value in self.__dict__.iteritems()]
10947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10948 
 
10949 
  def __eq__(self, other):
10950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10951 
 
10952 
  def __ne__(self, other):
10953 
    return not (self == other)
10954 
 
559 chandransh 10955 
class getCart_args:
504 rajveer 10956 
  """
10957 
  Attributes:
559 chandransh 10958 
   - cartId
504 rajveer 10959 
  """
10960 
 
10961 
  thrift_spec = (
10962 
    None, # 0
559 chandransh 10963 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10964 
  )
10965 
 
559 chandransh 10966 
  def __init__(self, cartId=None,):
10967 
    self.cartId = cartId
504 rajveer 10968 
 
10969 
  def read(self, iprot):
10970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10972 
      return
10973 
    iprot.readStructBegin()
10974 
    while True:
10975 
      (fname, ftype, fid) = iprot.readFieldBegin()
10976 
      if ftype == TType.STOP:
10977 
        break
10978 
      if fid == 1:
10979 
        if ftype == TType.I64:
559 chandransh 10980 
          self.cartId = iprot.readI64();
504 rajveer 10981 
        else:
10982 
          iprot.skip(ftype)
10983 
      else:
10984 
        iprot.skip(ftype)
10985 
      iprot.readFieldEnd()
10986 
    iprot.readStructEnd()
10987 
 
10988 
  def write(self, oprot):
10989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10991 
      return
559 chandransh 10992 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10993 
    if self.cartId is not None:
559 chandransh 10994 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10995 
      oprot.writeI64(self.cartId)
504 rajveer 10996 
      oprot.writeFieldEnd()
10997 
    oprot.writeFieldStop()
10998 
    oprot.writeStructEnd()
10999 
 
3431 rajveer 11000 
  def validate(self):
11001 
    return
11002 
 
11003 
 
504 rajveer 11004 
  def __repr__(self):
11005 
    L = ['%s=%r' % (key, value)
11006 
      for key, value in self.__dict__.iteritems()]
11007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11008 
 
11009 
  def __eq__(self, other):
11010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11011 
 
11012 
  def __ne__(self, other):
11013 
    return not (self == other)
11014 
 
559 chandransh 11015 
class getCart_result:
504 rajveer 11016 
  """
11017 
  Attributes:
11018 
   - success
559 chandransh 11019 
   - scx
504 rajveer 11020 
  """
11021 
 
11022 
  thrift_spec = (
559 chandransh 11023 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11024 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 11025 
  )
11026 
 
559 chandransh 11027 
  def __init__(self, success=None, scx=None,):
504 rajveer 11028 
    self.success = success
559 chandransh 11029 
    self.scx = scx
504 rajveer 11030 
 
11031 
  def read(self, iprot):
11032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11034 
      return
11035 
    iprot.readStructBegin()
11036 
    while True:
11037 
      (fname, ftype, fid) = iprot.readFieldBegin()
11038 
      if ftype == TType.STOP:
11039 
        break
11040 
      if fid == 0:
559 chandransh 11041 
        if ftype == TType.STRUCT:
11042 
          self.success = Cart()
11043 
          self.success.read(iprot)
504 rajveer 11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      elif fid == 1:
11047 
        if ftype == TType.STRUCT:
559 chandransh 11048 
          self.scx = ShoppingCartException()
11049 
          self.scx.read(iprot)
504 rajveer 11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      else:
11053 
        iprot.skip(ftype)
11054 
      iprot.readFieldEnd()
11055 
    iprot.readStructEnd()
11056 
 
11057 
  def write(self, oprot):
11058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11060 
      return
559 chandransh 11061 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11062 
    if self.success is not None:
559 chandransh 11063 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11064 
      self.success.write(oprot)
504 rajveer 11065 
      oprot.writeFieldEnd()
3431 rajveer 11066 
    if self.scx is not None:
559 chandransh 11067 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11068 
      self.scx.write(oprot)
504 rajveer 11069 
      oprot.writeFieldEnd()
11070 
    oprot.writeFieldStop()
11071 
    oprot.writeStructEnd()
11072 
 
3431 rajveer 11073 
  def validate(self):
11074 
    return
11075 
 
11076 
 
504 rajveer 11077 
  def __repr__(self):
11078 
    L = ['%s=%r' % (key, value)
11079 
      for key, value in self.__dict__.iteritems()]
11080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11081 
 
11082 
  def __eq__(self, other):
11083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11084 
 
11085 
  def __ne__(self, other):
11086 
    return not (self == other)
11087 
 
559 chandransh 11088 
class getCartsByTime_args:
11089 
  """
11090 
  Attributes:
11091 
   - from_time
11092 
   - to_time
11093 
   - status
11094 
  """
11095 
 
11096 
  thrift_spec = (
11097 
    None, # 0
11098 
    (1, TType.I64, 'from_time', None, None, ), # 1
11099 
    (2, TType.I64, 'to_time', None, None, ), # 2
11100 
    (3, TType.I32, 'status', None, None, ), # 3
11101 
  )
11102 
 
11103 
  def __init__(self, from_time=None, to_time=None, status=None,):
11104 
    self.from_time = from_time
11105 
    self.to_time = to_time
11106 
    self.status = status
11107 
 
11108 
  def read(self, iprot):
11109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11111 
      return
11112 
    iprot.readStructBegin()
11113 
    while True:
11114 
      (fname, ftype, fid) = iprot.readFieldBegin()
11115 
      if ftype == TType.STOP:
11116 
        break
11117 
      if fid == 1:
94 ashish 11118 
        if ftype == TType.I64:
559 chandransh 11119 
          self.from_time = iprot.readI64();
94 ashish 11120 
        else:
11121 
          iprot.skip(ftype)
122 ashish 11122 
      elif fid == 2:
559 chandransh 11123 
        if ftype == TType.I64:
11124 
          self.to_time = iprot.readI64();
122 ashish 11125 
        else:
11126 
          iprot.skip(ftype)
559 chandransh 11127 
      elif fid == 3:
11128 
        if ftype == TType.I32:
11129 
          self.status = iprot.readI32();
11130 
        else:
11131 
          iprot.skip(ftype)
94 ashish 11132 
      else:
11133 
        iprot.skip(ftype)
11134 
      iprot.readFieldEnd()
11135 
    iprot.readStructEnd()
11136 
 
11137 
  def write(self, oprot):
11138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11140 
      return
559 chandransh 11141 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11142 
    if self.from_time is not None:
559 chandransh 11143 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11144 
      oprot.writeI64(self.from_time)
94 ashish 11145 
      oprot.writeFieldEnd()
3431 rajveer 11146 
    if self.to_time is not None:
559 chandransh 11147 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11148 
      oprot.writeI64(self.to_time)
122 ashish 11149 
      oprot.writeFieldEnd()
3431 rajveer 11150 
    if self.status is not None:
559 chandransh 11151 
      oprot.writeFieldBegin('status', TType.I32, 3)
11152 
      oprot.writeI32(self.status)
11153 
      oprot.writeFieldEnd()
94 ashish 11154 
    oprot.writeFieldStop()
11155 
    oprot.writeStructEnd()
11156 
 
3431 rajveer 11157 
  def validate(self):
11158 
    return
11159 
 
11160 
 
94 ashish 11161 
  def __repr__(self):
11162 
    L = ['%s=%r' % (key, value)
11163 
      for key, value in self.__dict__.iteritems()]
11164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11165 
 
11166 
  def __eq__(self, other):
11167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11168 
 
11169 
  def __ne__(self, other):
11170 
    return not (self == other)
11171 
 
559 chandransh 11172 
class getCartsByTime_result:
94 ashish 11173 
  """
11174 
  Attributes:
11175 
   - success
559 chandransh 11176 
   - scx
94 ashish 11177 
  """
11178 
 
11179 
  thrift_spec = (
559 chandransh 11180 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11181 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11182 
  )
11183 
 
559 chandransh 11184 
  def __init__(self, success=None, scx=None,):
94 ashish 11185 
    self.success = success
559 chandransh 11186 
    self.scx = scx
94 ashish 11187 
 
11188 
  def read(self, iprot):
11189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11191 
      return
11192 
    iprot.readStructBegin()
11193 
    while True:
11194 
      (fname, ftype, fid) = iprot.readFieldBegin()
11195 
      if ftype == TType.STOP:
11196 
        break
11197 
      if fid == 0:
559 chandransh 11198 
        if ftype == TType.LIST:
11199 
          self.success = []
11592 amit.gupta 11200 
          (_etype156, _size153) = iprot.readListBegin()
11201 
          for _i157 in xrange(_size153):
11202 
            _elem158 = Cart()
11203 
            _elem158.read(iprot)
11204 
            self.success.append(_elem158)
559 chandransh 11205 
          iprot.readListEnd()
94 ashish 11206 
        else:
11207 
          iprot.skip(ftype)
11208 
      elif fid == 1:
11209 
        if ftype == TType.STRUCT:
559 chandransh 11210 
          self.scx = ShoppingCartException()
11211 
          self.scx.read(iprot)
94 ashish 11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      else:
11215 
        iprot.skip(ftype)
11216 
      iprot.readFieldEnd()
11217 
    iprot.readStructEnd()
11218 
 
11219 
  def write(self, oprot):
11220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11222 
      return
559 chandransh 11223 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11224 
    if self.success is not None:
559 chandransh 11225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11227 
      for iter159 in self.success:
11228 
        iter159.write(oprot)
559 chandransh 11229 
      oprot.writeListEnd()
94 ashish 11230 
      oprot.writeFieldEnd()
3431 rajveer 11231 
    if self.scx is not None:
559 chandransh 11232 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11233 
      self.scx.write(oprot)
94 ashish 11234 
      oprot.writeFieldEnd()
11235 
    oprot.writeFieldStop()
11236 
    oprot.writeStructEnd()
11237 
 
3431 rajveer 11238 
  def validate(self):
11239 
    return
11240 
 
11241 
 
94 ashish 11242 
  def __repr__(self):
11243 
    L = ['%s=%r' % (key, value)
11244 
      for key, value in self.__dict__.iteritems()]
11245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11246 
 
11247 
  def __eq__(self, other):
11248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11249 
 
11250 
  def __ne__(self, other):
11251 
    return not (self == other)
11252 
 
559 chandransh 11253 
class addItemToCart_args:
11254 
  """
11255 
  Attributes:
11256 
   - cartId
11257 
   - itemId
11258 
   - quantity
3557 rajveer 11259 
   - sourceId
559 chandransh 11260 
  """
11261 
 
11262 
  thrift_spec = (
11263 
    None, # 0
11264 
    (1, TType.I64, 'cartId', None, None, ), # 1
11265 
    (2, TType.I64, 'itemId', None, None, ), # 2
11266 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11267 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11268 
  )
11269 
 
3557 rajveer 11270 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11271 
    self.cartId = cartId
11272 
    self.itemId = itemId
11273 
    self.quantity = quantity
3557 rajveer 11274 
    self.sourceId = sourceId
559 chandransh 11275 
 
11276 
  def read(self, iprot):
11277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11279 
      return
11280 
    iprot.readStructBegin()
11281 
    while True:
11282 
      (fname, ftype, fid) = iprot.readFieldBegin()
11283 
      if ftype == TType.STOP:
11284 
        break
11285 
      if fid == 1:
11286 
        if ftype == TType.I64:
11287 
          self.cartId = iprot.readI64();
11288 
        else:
11289 
          iprot.skip(ftype)
11290 
      elif fid == 2:
11291 
        if ftype == TType.I64:
11292 
          self.itemId = iprot.readI64();
11293 
        else:
11294 
          iprot.skip(ftype)
11295 
      elif fid == 3:
11296 
        if ftype == TType.I64:
11297 
          self.quantity = iprot.readI64();
11298 
        else:
11299 
          iprot.skip(ftype)
3557 rajveer 11300 
      elif fid == 4:
11301 
        if ftype == TType.I64:
11302 
          self.sourceId = iprot.readI64();
11303 
        else:
11304 
          iprot.skip(ftype)
559 chandransh 11305 
      else:
11306 
        iprot.skip(ftype)
11307 
      iprot.readFieldEnd()
11308 
    iprot.readStructEnd()
11309 
 
11310 
  def write(self, oprot):
11311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11313 
      return
11314 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11315 
    if self.cartId is not None:
559 chandransh 11316 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11317 
      oprot.writeI64(self.cartId)
11318 
      oprot.writeFieldEnd()
3431 rajveer 11319 
    if self.itemId is not None:
559 chandransh 11320 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11321 
      oprot.writeI64(self.itemId)
11322 
      oprot.writeFieldEnd()
3431 rajveer 11323 
    if self.quantity is not None:
559 chandransh 11324 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11325 
      oprot.writeI64(self.quantity)
11326 
      oprot.writeFieldEnd()
3557 rajveer 11327 
    if self.sourceId is not None:
11328 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11329 
      oprot.writeI64(self.sourceId)
11330 
      oprot.writeFieldEnd()
559 chandransh 11331 
    oprot.writeFieldStop()
11332 
    oprot.writeStructEnd()
11333 
 
3431 rajveer 11334 
  def validate(self):
11335 
    return
11336 
 
11337 
 
559 chandransh 11338 
  def __repr__(self):
11339 
    L = ['%s=%r' % (key, value)
11340 
      for key, value in self.__dict__.iteritems()]
11341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11342 
 
11343 
  def __eq__(self, other):
11344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11345 
 
11346 
  def __ne__(self, other):
11347 
    return not (self == other)
11348 
 
11349 
class addItemToCart_result:
11350 
  """
11351 
  Attributes:
2035 rajveer 11352 
   - success
559 chandransh 11353 
   - scx
11354 
  """
11355 
 
11356 
  thrift_spec = (
2035 rajveer 11357 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11358 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11359 
  )
11360 
 
2035 rajveer 11361 
  def __init__(self, success=None, scx=None,):
11362 
    self.success = success
559 chandransh 11363 
    self.scx = scx
11364 
 
11365 
  def read(self, iprot):
11366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11368 
      return
11369 
    iprot.readStructBegin()
11370 
    while True:
11371 
      (fname, ftype, fid) = iprot.readFieldBegin()
11372 
      if ftype == TType.STOP:
11373 
        break
2035 rajveer 11374 
      if fid == 0:
11375 
        if ftype == TType.STRING:
11376 
          self.success = iprot.readString();
11377 
        else:
11378 
          iprot.skip(ftype)
11379 
      elif fid == 1:
559 chandransh 11380 
        if ftype == TType.STRUCT:
11381 
          self.scx = ShoppingCartException()
11382 
          self.scx.read(iprot)
11383 
        else:
11384 
          iprot.skip(ftype)
11385 
      else:
11386 
        iprot.skip(ftype)
11387 
      iprot.readFieldEnd()
11388 
    iprot.readStructEnd()
11389 
 
11390 
  def write(self, oprot):
11391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11393 
      return
11394 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11395 
    if self.success is not None:
2035 rajveer 11396 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11397 
      oprot.writeString(self.success)
11398 
      oprot.writeFieldEnd()
3431 rajveer 11399 
    if self.scx is not None:
559 chandransh 11400 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11401 
      self.scx.write(oprot)
11402 
      oprot.writeFieldEnd()
11403 
    oprot.writeFieldStop()
11404 
    oprot.writeStructEnd()
11405 
 
3431 rajveer 11406 
  def validate(self):
11407 
    return
11408 
 
11409 
 
559 chandransh 11410 
  def __repr__(self):
11411 
    L = ['%s=%r' % (key, value)
11412 
      for key, value in self.__dict__.iteritems()]
11413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11414 
 
11415 
  def __eq__(self, other):
11416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11417 
 
11418 
  def __ne__(self, other):
11419 
    return not (self == other)
11420 
 
11421 
class deleteItemFromCart_args:
11422 
  """
11423 
  Attributes:
11424 
   - cartId
11425 
   - itemId
11426 
  """
11427 
 
11428 
  thrift_spec = (
11429 
    None, # 0
11430 
    (1, TType.I64, 'cartId', None, None, ), # 1
11431 
    (2, TType.I64, 'itemId', None, None, ), # 2
11432 
  )
11433 
 
11434 
  def __init__(self, cartId=None, itemId=None,):
11435 
    self.cartId = cartId
11436 
    self.itemId = itemId
11437 
 
11438 
  def read(self, iprot):
11439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11441 
      return
11442 
    iprot.readStructBegin()
11443 
    while True:
11444 
      (fname, ftype, fid) = iprot.readFieldBegin()
11445 
      if ftype == TType.STOP:
11446 
        break
11447 
      if fid == 1:
11448 
        if ftype == TType.I64:
11449 
          self.cartId = iprot.readI64();
11450 
        else:
11451 
          iprot.skip(ftype)
11452 
      elif fid == 2:
11453 
        if ftype == TType.I64:
11454 
          self.itemId = iprot.readI64();
11455 
        else:
11456 
          iprot.skip(ftype)
11457 
      else:
11458 
        iprot.skip(ftype)
11459 
      iprot.readFieldEnd()
11460 
    iprot.readStructEnd()
11461 
 
11462 
  def write(self, oprot):
11463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11465 
      return
11466 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11467 
    if self.cartId is not None:
559 chandransh 11468 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11469 
      oprot.writeI64(self.cartId)
11470 
      oprot.writeFieldEnd()
3431 rajveer 11471 
    if self.itemId is not None:
559 chandransh 11472 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11473 
      oprot.writeI64(self.itemId)
11474 
      oprot.writeFieldEnd()
11475 
    oprot.writeFieldStop()
11476 
    oprot.writeStructEnd()
11477 
 
3431 rajveer 11478 
  def validate(self):
11479 
    return
11480 
 
11481 
 
559 chandransh 11482 
  def __repr__(self):
11483 
    L = ['%s=%r' % (key, value)
11484 
      for key, value in self.__dict__.iteritems()]
11485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11486 
 
11487 
  def __eq__(self, other):
11488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11489 
 
11490 
  def __ne__(self, other):
11491 
    return not (self == other)
11492 
 
11493 
class deleteItemFromCart_result:
11494 
  """
11495 
  Attributes:
11496 
   - scx
11497 
  """
11498 
 
11499 
  thrift_spec = (
11500 
    None, # 0
11501 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11502 
  )
11503 
 
11504 
  def __init__(self, scx=None,):
11505 
    self.scx = scx
11506 
 
11507 
  def read(self, iprot):
11508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11510 
      return
11511 
    iprot.readStructBegin()
11512 
    while True:
11513 
      (fname, ftype, fid) = iprot.readFieldBegin()
11514 
      if ftype == TType.STOP:
11515 
        break
11516 
      if fid == 1:
11517 
        if ftype == TType.STRUCT:
11518 
          self.scx = ShoppingCartException()
11519 
          self.scx.read(iprot)
11520 
        else:
11521 
          iprot.skip(ftype)
11522 
      else:
11523 
        iprot.skip(ftype)
11524 
      iprot.readFieldEnd()
11525 
    iprot.readStructEnd()
11526 
 
11527 
  def write(self, oprot):
11528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11530 
      return
11531 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11532 
    if self.scx is not None:
559 chandransh 11533 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11534 
      self.scx.write(oprot)
11535 
      oprot.writeFieldEnd()
11536 
    oprot.writeFieldStop()
11537 
    oprot.writeStructEnd()
11538 
 
3431 rajveer 11539 
  def validate(self):
11540 
    return
11541 
 
11542 
 
559 chandransh 11543 
  def __repr__(self):
11544 
    L = ['%s=%r' % (key, value)
11545 
      for key, value in self.__dict__.iteritems()]
11546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11547 
 
11548 
  def __eq__(self, other):
11549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11550 
 
11551 
  def __ne__(self, other):
11552 
    return not (self == other)
11553 
 
11554 
class addAddressToCart_args:
11555 
  """
11556 
  Attributes:
11557 
   - cartId
11558 
   - addressId
11559 
  """
11560 
 
11561 
  thrift_spec = (
11562 
    None, # 0
11563 
    (1, TType.I64, 'cartId', None, None, ), # 1
11564 
    (2, TType.I64, 'addressId', None, None, ), # 2
11565 
  )
11566 
 
11567 
  def __init__(self, cartId=None, addressId=None,):
11568 
    self.cartId = cartId
11569 
    self.addressId = addressId
11570 
 
11571 
  def read(self, iprot):
11572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11574 
      return
11575 
    iprot.readStructBegin()
11576 
    while True:
11577 
      (fname, ftype, fid) = iprot.readFieldBegin()
11578 
      if ftype == TType.STOP:
11579 
        break
11580 
      if fid == 1:
11581 
        if ftype == TType.I64:
11582 
          self.cartId = iprot.readI64();
11583 
        else:
11584 
          iprot.skip(ftype)
11585 
      elif fid == 2:
11586 
        if ftype == TType.I64:
11587 
          self.addressId = iprot.readI64();
11588 
        else:
11589 
          iprot.skip(ftype)
11590 
      else:
11591 
        iprot.skip(ftype)
11592 
      iprot.readFieldEnd()
11593 
    iprot.readStructEnd()
11594 
 
11595 
  def write(self, oprot):
11596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11598 
      return
11599 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11600 
    if self.cartId is not None:
559 chandransh 11601 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11602 
      oprot.writeI64(self.cartId)
11603 
      oprot.writeFieldEnd()
3431 rajveer 11604 
    if self.addressId is not None:
559 chandransh 11605 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11606 
      oprot.writeI64(self.addressId)
11607 
      oprot.writeFieldEnd()
11608 
    oprot.writeFieldStop()
11609 
    oprot.writeStructEnd()
11610 
 
3431 rajveer 11611 
  def validate(self):
11612 
    return
11613 
 
11614 
 
559 chandransh 11615 
  def __repr__(self):
11616 
    L = ['%s=%r' % (key, value)
11617 
      for key, value in self.__dict__.iteritems()]
11618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11619 
 
11620 
  def __eq__(self, other):
11621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11622 
 
11623 
  def __ne__(self, other):
11624 
    return not (self == other)
11625 
 
11626 
class addAddressToCart_result:
575 chandransh 11627 
  """
11628 
  Attributes:
11629 
   - scx
11630 
  """
559 chandransh 11631 
 
11632 
  thrift_spec = (
575 chandransh 11633 
    None, # 0
11634 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11635 
  )
11636 
 
575 chandransh 11637 
  def __init__(self, scx=None,):
11638 
    self.scx = scx
11639 
 
559 chandransh 11640 
  def read(self, iprot):
11641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11643 
      return
11644 
    iprot.readStructBegin()
11645 
    while True:
11646 
      (fname, ftype, fid) = iprot.readFieldBegin()
11647 
      if ftype == TType.STOP:
11648 
        break
575 chandransh 11649 
      if fid == 1:
11650 
        if ftype == TType.STRUCT:
11651 
          self.scx = ShoppingCartException()
11652 
          self.scx.read(iprot)
11653 
        else:
11654 
          iprot.skip(ftype)
559 chandransh 11655 
      else:
11656 
        iprot.skip(ftype)
11657 
      iprot.readFieldEnd()
11658 
    iprot.readStructEnd()
11659 
 
11660 
  def write(self, oprot):
11661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11663 
      return
11664 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11665 
    if self.scx is not None:
575 chandransh 11666 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11667 
      self.scx.write(oprot)
11668 
      oprot.writeFieldEnd()
559 chandransh 11669 
    oprot.writeFieldStop()
11670 
    oprot.writeStructEnd()
11671 
 
3431 rajveer 11672 
  def validate(self):
11673 
    return
11674 
 
11675 
 
559 chandransh 11676 
  def __repr__(self):
11677 
    L = ['%s=%r' % (key, value)
11678 
      for key, value in self.__dict__.iteritems()]
11679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11680 
 
11681 
  def __eq__(self, other):
11682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11683 
 
11684 
  def __ne__(self, other):
11685 
    return not (self == other)
11686 
 
5553 rajveer 11687 
class addStoreToCart_args:
11688 
  """
11689 
  Attributes:
11690 
   - cartId
11691 
   - storeId
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    None, # 0
11696 
    (1, TType.I64, 'cartId', None, None, ), # 1
11697 
    (2, TType.I64, 'storeId', None, None, ), # 2
11698 
  )
11699 
 
11700 
  def __init__(self, cartId=None, storeId=None,):
11701 
    self.cartId = cartId
11702 
    self.storeId = storeId
11703 
 
11704 
  def read(self, iprot):
11705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11707 
      return
11708 
    iprot.readStructBegin()
11709 
    while True:
11710 
      (fname, ftype, fid) = iprot.readFieldBegin()
11711 
      if ftype == TType.STOP:
11712 
        break
11713 
      if fid == 1:
11714 
        if ftype == TType.I64:
11715 
          self.cartId = iprot.readI64();
11716 
        else:
11717 
          iprot.skip(ftype)
11718 
      elif fid == 2:
11719 
        if ftype == TType.I64:
11720 
          self.storeId = iprot.readI64();
11721 
        else:
11722 
          iprot.skip(ftype)
11723 
      else:
11724 
        iprot.skip(ftype)
11725 
      iprot.readFieldEnd()
11726 
    iprot.readStructEnd()
11727 
 
11728 
  def write(self, oprot):
11729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11731 
      return
11732 
    oprot.writeStructBegin('addStoreToCart_args')
11733 
    if self.cartId is not None:
11734 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11735 
      oprot.writeI64(self.cartId)
11736 
      oprot.writeFieldEnd()
11737 
    if self.storeId is not None:
11738 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11739 
      oprot.writeI64(self.storeId)
11740 
      oprot.writeFieldEnd()
11741 
    oprot.writeFieldStop()
11742 
    oprot.writeStructEnd()
11743 
 
11744 
  def validate(self):
11745 
    return
11746 
 
11747 
 
11748 
  def __repr__(self):
11749 
    L = ['%s=%r' % (key, value)
11750 
      for key, value in self.__dict__.iteritems()]
11751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11752 
 
11753 
  def __eq__(self, other):
11754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11755 
 
11756 
  def __ne__(self, other):
11757 
    return not (self == other)
11758 
 
11759 
class addStoreToCart_result:
11760 
  """
11761 
  Attributes:
11762 
   - scx
11763 
  """
11764 
 
11765 
  thrift_spec = (
11766 
    None, # 0
11767 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11768 
  )
11769 
 
11770 
  def __init__(self, scx=None,):
11771 
    self.scx = scx
11772 
 
11773 
  def read(self, iprot):
11774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11776 
      return
11777 
    iprot.readStructBegin()
11778 
    while True:
11779 
      (fname, ftype, fid) = iprot.readFieldBegin()
11780 
      if ftype == TType.STOP:
11781 
        break
11782 
      if fid == 1:
11783 
        if ftype == TType.STRUCT:
11784 
          self.scx = ShoppingCartException()
11785 
          self.scx.read(iprot)
11786 
        else:
11787 
          iprot.skip(ftype)
11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
11797 
    oprot.writeStructBegin('addStoreToCart_result')
11798 
    if self.scx is not None:
11799 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11800 
      self.scx.write(oprot)
11801 
      oprot.writeFieldEnd()
11802 
    oprot.writeFieldStop()
11803 
    oprot.writeStructEnd()
11804 
 
11805 
  def validate(self):
11806 
    return
11807 
 
11808 
 
11809 
  def __repr__(self):
11810 
    L = ['%s=%r' % (key, value)
11811 
      for key, value in self.__dict__.iteritems()]
11812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11813 
 
11814 
  def __eq__(self, other):
11815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11816 
 
11817 
  def __ne__(self, other):
11818 
    return not (self == other)
11819 
 
1976 varun.gupt 11820 
class applyCouponToCart_args:
11821 
  """
11822 
  Attributes:
6922 anupam.sin 11823 
   - cart
1976 varun.gupt 11824 
   - couponCode
11825 
  """
11826 
 
11827 
  thrift_spec = (
11828 
    None, # 0
6922 anupam.sin 11829 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11830 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11831 
  )
11832 
 
6922 anupam.sin 11833 
  def __init__(self, cart=None, couponCode=None,):
11834 
    self.cart = cart
1976 varun.gupt 11835 
    self.couponCode = couponCode
11836 
 
11837 
  def read(self, iprot):
11838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11840 
      return
11841 
    iprot.readStructBegin()
11842 
    while True:
11843 
      (fname, ftype, fid) = iprot.readFieldBegin()
11844 
      if ftype == TType.STOP:
11845 
        break
11846 
      if fid == 1:
6922 anupam.sin 11847 
        if ftype == TType.STRUCT:
11848 
          self.cart = Cart()
11849 
          self.cart.read(iprot)
1976 varun.gupt 11850 
        else:
11851 
          iprot.skip(ftype)
11852 
      elif fid == 2:
11853 
        if ftype == TType.STRING:
11854 
          self.couponCode = iprot.readString();
11855 
        else:
11856 
          iprot.skip(ftype)
11857 
      else:
11858 
        iprot.skip(ftype)
11859 
      iprot.readFieldEnd()
11860 
    iprot.readStructEnd()
11861 
 
11862 
  def write(self, oprot):
11863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11865 
      return
11866 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11867 
    if self.cart is not None:
11868 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11869 
      self.cart.write(oprot)
1976 varun.gupt 11870 
      oprot.writeFieldEnd()
3431 rajveer 11871 
    if self.couponCode is not None:
1976 varun.gupt 11872 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11873 
      oprot.writeString(self.couponCode)
11874 
      oprot.writeFieldEnd()
11875 
    oprot.writeFieldStop()
11876 
    oprot.writeStructEnd()
11877 
 
3431 rajveer 11878 
  def validate(self):
11879 
    return
11880 
 
11881 
 
1976 varun.gupt 11882 
  def __repr__(self):
11883 
    L = ['%s=%r' % (key, value)
11884 
      for key, value in self.__dict__.iteritems()]
11885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11886 
 
11887 
  def __eq__(self, other):
11888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11889 
 
11890 
  def __ne__(self, other):
11891 
    return not (self == other)
11892 
 
11893 
class applyCouponToCart_result:
11894 
  """
11895 
  Attributes:
11896 
   - scx
11897 
  """
11898 
 
11899 
  thrift_spec = (
11900 
    None, # 0
11901 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11902 
  )
11903 
 
11904 
  def __init__(self, scx=None,):
11905 
    self.scx = scx
11906 
 
11907 
  def read(self, iprot):
11908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11910 
      return
11911 
    iprot.readStructBegin()
11912 
    while True:
11913 
      (fname, ftype, fid) = iprot.readFieldBegin()
11914 
      if ftype == TType.STOP:
11915 
        break
11916 
      if fid == 1:
11917 
        if ftype == TType.STRUCT:
11918 
          self.scx = ShoppingCartException()
11919 
          self.scx.read(iprot)
11920 
        else:
11921 
          iprot.skip(ftype)
11922 
      else:
11923 
        iprot.skip(ftype)
11924 
      iprot.readFieldEnd()
11925 
    iprot.readStructEnd()
11926 
 
11927 
  def write(self, oprot):
11928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11930 
      return
11931 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11932 
    if self.scx is not None:
1976 varun.gupt 11933 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11934 
      self.scx.write(oprot)
11935 
      oprot.writeFieldEnd()
11936 
    oprot.writeFieldStop()
11937 
    oprot.writeStructEnd()
11938 
 
3431 rajveer 11939 
  def validate(self):
11940 
    return
11941 
 
11942 
 
1976 varun.gupt 11943 
  def __repr__(self):
11944 
    L = ['%s=%r' % (key, value)
11945 
      for key, value in self.__dict__.iteritems()]
11946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11947 
 
11948 
  def __eq__(self, other):
11949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11950 
 
11951 
  def __ne__(self, other):
11952 
    return not (self == other)
11953 
 
11954 
class removeCoupon_args:
11955 
  """
11956 
  Attributes:
11957 
   - cartId
11958 
  """
11959 
 
11960 
  thrift_spec = (
11961 
    None, # 0
11962 
    (1, TType.I64, 'cartId', None, None, ), # 1
11963 
  )
11964 
 
11965 
  def __init__(self, cartId=None,):
11966 
    self.cartId = cartId
11967 
 
11968 
  def read(self, iprot):
11969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11971 
      return
11972 
    iprot.readStructBegin()
11973 
    while True:
11974 
      (fname, ftype, fid) = iprot.readFieldBegin()
11975 
      if ftype == TType.STOP:
11976 
        break
11977 
      if fid == 1:
11978 
        if ftype == TType.I64:
11979 
          self.cartId = iprot.readI64();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      else:
11983 
        iprot.skip(ftype)
11984 
      iprot.readFieldEnd()
11985 
    iprot.readStructEnd()
11986 
 
11987 
  def write(self, oprot):
11988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11990 
      return
11991 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11992 
    if self.cartId is not None:
1976 varun.gupt 11993 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11994 
      oprot.writeI64(self.cartId)
11995 
      oprot.writeFieldEnd()
11996 
    oprot.writeFieldStop()
11997 
    oprot.writeStructEnd()
11998 
 
3431 rajveer 11999 
  def validate(self):
12000 
    return
12001 
 
12002 
 
1976 varun.gupt 12003 
  def __repr__(self):
12004 
    L = ['%s=%r' % (key, value)
12005 
      for key, value in self.__dict__.iteritems()]
12006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12007 
 
12008 
  def __eq__(self, other):
12009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12010 
 
12011 
  def __ne__(self, other):
12012 
    return not (self == other)
12013 
 
12014 
class removeCoupon_result:
12015 
  """
12016 
  Attributes:
12017 
   - scx
12018 
  """
12019 
 
12020 
  thrift_spec = (
12021 
    None, # 0
12022 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12023 
  )
12024 
 
12025 
  def __init__(self, scx=None,):
12026 
    self.scx = scx
12027 
 
12028 
  def read(self, iprot):
12029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12031 
      return
12032 
    iprot.readStructBegin()
12033 
    while True:
12034 
      (fname, ftype, fid) = iprot.readFieldBegin()
12035 
      if ftype == TType.STOP:
12036 
        break
12037 
      if fid == 1:
12038 
        if ftype == TType.STRUCT:
12039 
          self.scx = ShoppingCartException()
12040 
          self.scx.read(iprot)
12041 
        else:
12042 
          iprot.skip(ftype)
12043 
      else:
12044 
        iprot.skip(ftype)
12045 
      iprot.readFieldEnd()
12046 
    iprot.readStructEnd()
12047 
 
12048 
  def write(self, oprot):
12049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12051 
      return
12052 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 12053 
    if self.scx is not None:
1976 varun.gupt 12054 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12055 
      self.scx.write(oprot)
12056 
      oprot.writeFieldEnd()
12057 
    oprot.writeFieldStop()
12058 
    oprot.writeStructEnd()
12059 
 
3431 rajveer 12060 
  def validate(self):
12061 
    return
12062 
 
12063 
 
1976 varun.gupt 12064 
  def __repr__(self):
12065 
    L = ['%s=%r' % (key, value)
12066 
      for key, value in self.__dict__.iteritems()]
12067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12068 
 
12069 
  def __eq__(self, other):
12070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12071 
 
12072 
  def __ne__(self, other):
12073 
    return not (self == other)
12074 
 
3554 varun.gupt 12075 
class deleteDiscountsFromCart_args:
12076 
  """
12077 
  Attributes:
12078 
   - cartId
12079 
  """
12080 
 
12081 
  thrift_spec = (
12082 
    None, # 0
12083 
    (1, TType.I64, 'cartId', None, None, ), # 1
12084 
  )
12085 
 
12086 
  def __init__(self, cartId=None,):
12087 
    self.cartId = cartId
12088 
 
12089 
  def read(self, iprot):
12090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12092 
      return
12093 
    iprot.readStructBegin()
12094 
    while True:
12095 
      (fname, ftype, fid) = iprot.readFieldBegin()
12096 
      if ftype == TType.STOP:
12097 
        break
12098 
      if fid == 1:
12099 
        if ftype == TType.I64:
12100 
          self.cartId = iprot.readI64();
12101 
        else:
12102 
          iprot.skip(ftype)
12103 
      else:
12104 
        iprot.skip(ftype)
12105 
      iprot.readFieldEnd()
12106 
    iprot.readStructEnd()
12107 
 
12108 
  def write(self, oprot):
12109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12111 
      return
12112 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12113 
    if self.cartId is not None:
12114 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12115 
      oprot.writeI64(self.cartId)
12116 
      oprot.writeFieldEnd()
12117 
    oprot.writeFieldStop()
12118 
    oprot.writeStructEnd()
12119 
 
12120 
  def validate(self):
12121 
    return
12122 
 
12123 
 
12124 
  def __repr__(self):
12125 
    L = ['%s=%r' % (key, value)
12126 
      for key, value in self.__dict__.iteritems()]
12127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12128 
 
12129 
  def __eq__(self, other):
12130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12131 
 
12132 
  def __ne__(self, other):
12133 
    return not (self == other)
12134 
 
12135 
class deleteDiscountsFromCart_result:
12136 
  """
12137 
  Attributes:
12138 
   - scx
12139 
  """
12140 
 
12141 
  thrift_spec = (
12142 
    None, # 0
12143 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12144 
  )
12145 
 
12146 
  def __init__(self, scx=None,):
12147 
    self.scx = scx
12148 
 
12149 
  def read(self, iprot):
12150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12152 
      return
12153 
    iprot.readStructBegin()
12154 
    while True:
12155 
      (fname, ftype, fid) = iprot.readFieldBegin()
12156 
      if ftype == TType.STOP:
12157 
        break
12158 
      if fid == 1:
12159 
        if ftype == TType.STRUCT:
12160 
          self.scx = ShoppingCartException()
12161 
          self.scx.read(iprot)
12162 
        else:
12163 
          iprot.skip(ftype)
12164 
      else:
12165 
        iprot.skip(ftype)
12166 
      iprot.readFieldEnd()
12167 
    iprot.readStructEnd()
12168 
 
12169 
  def write(self, oprot):
12170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12172 
      return
12173 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12174 
    if self.scx is not None:
12175 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12176 
      self.scx.write(oprot)
12177 
      oprot.writeFieldEnd()
12178 
    oprot.writeFieldStop()
12179 
    oprot.writeStructEnd()
12180 
 
12181 
  def validate(self):
12182 
    return
12183 
 
12184 
 
12185 
  def __repr__(self):
12186 
    L = ['%s=%r' % (key, value)
12187 
      for key, value in self.__dict__.iteritems()]
12188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12189 
 
12190 
  def __eq__(self, other):
12191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12192 
 
12193 
  def __ne__(self, other):
12194 
    return not (self == other)
12195 
 
12196 
class saveDiscounts_args:
12197 
  """
12198 
  Attributes:
12199 
   - discounts
12200 
  """
12201 
 
12202 
  thrift_spec = (
12203 
    None, # 0
12204 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12205 
  )
12206 
 
12207 
  def __init__(self, discounts=None,):
12208 
    self.discounts = discounts
12209 
 
12210 
  def read(self, iprot):
12211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12213 
      return
12214 
    iprot.readStructBegin()
12215 
    while True:
12216 
      (fname, ftype, fid) = iprot.readFieldBegin()
12217 
      if ftype == TType.STOP:
12218 
        break
12219 
      if fid == 1:
12220 
        if ftype == TType.LIST:
12221 
          self.discounts = []
11592 amit.gupta 12222 
          (_etype163, _size160) = iprot.readListBegin()
12223 
          for _i164 in xrange(_size160):
12224 
            _elem165 = Discount()
12225 
            _elem165.read(iprot)
12226 
            self.discounts.append(_elem165)
3554 varun.gupt 12227 
          iprot.readListEnd()
12228 
        else:
12229 
          iprot.skip(ftype)
12230 
      else:
12231 
        iprot.skip(ftype)
12232 
      iprot.readFieldEnd()
12233 
    iprot.readStructEnd()
12234 
 
12235 
  def write(self, oprot):
12236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12238 
      return
12239 
    oprot.writeStructBegin('saveDiscounts_args')
12240 
    if self.discounts is not None:
12241 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12242 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12243 
      for iter166 in self.discounts:
12244 
        iter166.write(oprot)
3554 varun.gupt 12245 
      oprot.writeListEnd()
12246 
      oprot.writeFieldEnd()
12247 
    oprot.writeFieldStop()
12248 
    oprot.writeStructEnd()
12249 
 
12250 
  def validate(self):
12251 
    return
12252 
 
12253 
 
12254 
  def __repr__(self):
12255 
    L = ['%s=%r' % (key, value)
12256 
      for key, value in self.__dict__.iteritems()]
12257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12258 
 
12259 
  def __eq__(self, other):
12260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12261 
 
12262 
  def __ne__(self, other):
12263 
    return not (self == other)
12264 
 
12265 
class saveDiscounts_result:
12266 
  """
12267 
  Attributes:
12268 
   - scx
12269 
  """
12270 
 
12271 
  thrift_spec = (
12272 
    None, # 0
12273 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12274 
  )
12275 
 
12276 
  def __init__(self, scx=None,):
12277 
    self.scx = scx
12278 
 
12279 
  def read(self, iprot):
12280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12282 
      return
12283 
    iprot.readStructBegin()
12284 
    while True:
12285 
      (fname, ftype, fid) = iprot.readFieldBegin()
12286 
      if ftype == TType.STOP:
12287 
        break
12288 
      if fid == 1:
12289 
        if ftype == TType.STRUCT:
12290 
          self.scx = ShoppingCartException()
12291 
          self.scx.read(iprot)
12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      else:
12295 
        iprot.skip(ftype)
12296 
      iprot.readFieldEnd()
12297 
    iprot.readStructEnd()
12298 
 
12299 
  def write(self, oprot):
12300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12302 
      return
12303 
    oprot.writeStructBegin('saveDiscounts_result')
12304 
    if self.scx is not None:
12305 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12306 
      self.scx.write(oprot)
12307 
      oprot.writeFieldEnd()
12308 
    oprot.writeFieldStop()
12309 
    oprot.writeStructEnd()
12310 
 
12311 
  def validate(self):
12312 
    return
12313 
 
12314 
 
12315 
  def __repr__(self):
12316 
    L = ['%s=%r' % (key, value)
12317 
      for key, value in self.__dict__.iteritems()]
12318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12319 
 
12320 
  def __eq__(self, other):
12321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12322 
 
12323 
  def __ne__(self, other):
12324 
    return not (self == other)
12325 
 
690 chandransh 12326 
class createOrders_args:
559 chandransh 12327 
  """
12328 
  Attributes:
12329 
   - cartId
2815 vikas 12330 
   - sessionSource
12331 
   - sessionStartTime
3858 vikas 12332 
   - firstSource
12333 
   - firstSourceTime
5326 rajveer 12334 
   - userId
6389 rajveer 12335 
   - schemeId
11526 amit.gupta 12336 
   - orderSource
21454 amit.gupta 12337 
   - selfPickup
559 chandransh 12338 
  """
12339 
 
12340 
  thrift_spec = (
12341 
    None, # 0
12342 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12343 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12344 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12345 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12346 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12347 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12348 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12349 
    (8, TType.I64, 'orderSource', None, None, ), # 8
21454 amit.gupta 12350 
    (9, TType.BOOL, 'selfPickup', None, None, ), # 9
559 chandransh 12351 
  )
12352 
 
21454 amit.gupta 12353 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None, selfPickup=None,):
559 chandransh 12354 
    self.cartId = cartId
2815 vikas 12355 
    self.sessionSource = sessionSource
12356 
    self.sessionStartTime = sessionStartTime
3858 vikas 12357 
    self.firstSource = firstSource
12358 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12359 
    self.userId = userId
6389 rajveer 12360 
    self.schemeId = schemeId
11526 amit.gupta 12361 
    self.orderSource = orderSource
21454 amit.gupta 12362 
    self.selfPickup = selfPickup
559 chandransh 12363 
 
12364 
  def read(self, iprot):
12365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12367 
      return
12368 
    iprot.readStructBegin()
12369 
    while True:
12370 
      (fname, ftype, fid) = iprot.readFieldBegin()
12371 
      if ftype == TType.STOP:
12372 
        break
12373 
      if fid == 1:
12374 
        if ftype == TType.I64:
12375 
          self.cartId = iprot.readI64();
12376 
        else:
12377 
          iprot.skip(ftype)
2815 vikas 12378 
      elif fid == 2:
12379 
        if ftype == TType.STRING:
12380 
          self.sessionSource = iprot.readString();
12381 
        else:
12382 
          iprot.skip(ftype)
12383 
      elif fid == 3:
12384 
        if ftype == TType.I64:
12385 
          self.sessionStartTime = iprot.readI64();
12386 
        else:
12387 
          iprot.skip(ftype)
3858 vikas 12388 
      elif fid == 4:
12389 
        if ftype == TType.STRING:
12390 
          self.firstSource = iprot.readString();
12391 
        else:
12392 
          iprot.skip(ftype)
12393 
      elif fid == 5:
12394 
        if ftype == TType.I64:
12395 
          self.firstSourceTime = iprot.readI64();
12396 
        else:
12397 
          iprot.skip(ftype)
5326 rajveer 12398 
      elif fid == 6:
12399 
        if ftype == TType.I64:
12400 
          self.userId = iprot.readI64();
12401 
        else:
12402 
          iprot.skip(ftype)
6389 rajveer 12403 
      elif fid == 7:
12404 
        if ftype == TType.I64:
12405 
          self.schemeId = iprot.readI64();
12406 
        else:
12407 
          iprot.skip(ftype)
11526 amit.gupta 12408 
      elif fid == 8:
12409 
        if ftype == TType.I64:
12410 
          self.orderSource = iprot.readI64();
12411 
        else:
12412 
          iprot.skip(ftype)
21454 amit.gupta 12413 
      elif fid == 9:
12414 
        if ftype == TType.BOOL:
12415 
          self.selfPickup = iprot.readBool();
12416 
        else:
12417 
          iprot.skip(ftype)
559 chandransh 12418 
      else:
12419 
        iprot.skip(ftype)
12420 
      iprot.readFieldEnd()
12421 
    iprot.readStructEnd()
12422 
 
12423 
  def write(self, oprot):
12424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12426 
      return
690 chandransh 12427 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12428 
    if self.cartId is not None:
559 chandransh 12429 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12430 
      oprot.writeI64(self.cartId)
12431 
      oprot.writeFieldEnd()
3431 rajveer 12432 
    if self.sessionSource is not None:
2815 vikas 12433 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12434 
      oprot.writeString(self.sessionSource)
12435 
      oprot.writeFieldEnd()
3431 rajveer 12436 
    if self.sessionStartTime is not None:
2815 vikas 12437 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12438 
      oprot.writeI64(self.sessionStartTime)
12439 
      oprot.writeFieldEnd()
3858 vikas 12440 
    if self.firstSource is not None:
12441 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12442 
      oprot.writeString(self.firstSource)
12443 
      oprot.writeFieldEnd()
12444 
    if self.firstSourceTime is not None:
12445 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12446 
      oprot.writeI64(self.firstSourceTime)
12447 
      oprot.writeFieldEnd()
5326 rajveer 12448 
    if self.userId is not None:
12449 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12450 
      oprot.writeI64(self.userId)
12451 
      oprot.writeFieldEnd()
6389 rajveer 12452 
    if self.schemeId is not None:
12453 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12454 
      oprot.writeI64(self.schemeId)
12455 
      oprot.writeFieldEnd()
11526 amit.gupta 12456 
    if self.orderSource is not None:
12457 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12458 
      oprot.writeI64(self.orderSource)
12459 
      oprot.writeFieldEnd()
21454 amit.gupta 12460 
    if self.selfPickup is not None:
12461 
      oprot.writeFieldBegin('selfPickup', TType.BOOL, 9)
12462 
      oprot.writeBool(self.selfPickup)
12463 
      oprot.writeFieldEnd()
559 chandransh 12464 
    oprot.writeFieldStop()
12465 
    oprot.writeStructEnd()
12466 
 
3431 rajveer 12467 
  def validate(self):
12468 
    return
12469 
 
12470 
 
559 chandransh 12471 
  def __repr__(self):
12472 
    L = ['%s=%r' % (key, value)
12473 
      for key, value in self.__dict__.iteritems()]
12474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12475 
 
12476 
  def __eq__(self, other):
12477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12478 
 
12479 
  def __ne__(self, other):
12480 
    return not (self == other)
12481 
 
690 chandransh 12482 
class createOrders_result:
559 chandransh 12483 
  """
12484 
  Attributes:
94 ashish 12485 
   - success
559 chandransh 12486 
   - scx
94 ashish 12487 
  """
12488 
 
12489 
  thrift_spec = (
575 chandransh 12490 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12491 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12492 
  )
12493 
 
559 chandransh 12494 
  def __init__(self, success=None, scx=None,):
94 ashish 12495 
    self.success = success
559 chandransh 12496 
    self.scx = scx
94 ashish 12497 
 
12498 
  def read(self, iprot):
12499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12501 
      return
12502 
    iprot.readStructBegin()
12503 
    while True:
12504 
      (fname, ftype, fid) = iprot.readFieldBegin()
12505 
      if ftype == TType.STOP:
12506 
        break
12507 
      if fid == 0:
575 chandransh 12508 
        if ftype == TType.I64:
12509 
          self.success = iprot.readI64();
94 ashish 12510 
        else:
12511 
          iprot.skip(ftype)
12512 
      elif fid == 1:
12513 
        if ftype == TType.STRUCT:
559 chandransh 12514 
          self.scx = ShoppingCartException()
12515 
          self.scx.read(iprot)
94 ashish 12516 
        else:
12517 
          iprot.skip(ftype)
12518 
      else:
12519 
        iprot.skip(ftype)
12520 
      iprot.readFieldEnd()
12521 
    iprot.readStructEnd()
12522 
 
12523 
  def write(self, oprot):
12524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12526 
      return
690 chandransh 12527 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12528 
    if self.success is not None:
575 chandransh 12529 
      oprot.writeFieldBegin('success', TType.I64, 0)
12530 
      oprot.writeI64(self.success)
94 ashish 12531 
      oprot.writeFieldEnd()
3431 rajveer 12532 
    if self.scx is not None:
559 chandransh 12533 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12534 
      self.scx.write(oprot)
94 ashish 12535 
      oprot.writeFieldEnd()
12536 
    oprot.writeFieldStop()
12537 
    oprot.writeStructEnd()
12538 
 
3431 rajveer 12539 
  def validate(self):
12540 
    return
12541 
 
12542 
 
94 ashish 12543 
  def __repr__(self):
12544 
    L = ['%s=%r' % (key, value)
12545 
      for key, value in self.__dict__.iteritems()]
12546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12547 
 
12548 
  def __eq__(self, other):
12549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12550 
 
12551 
  def __ne__(self, other):
12552 
    return not (self == other)
12553 
 
559 chandransh 12554 
class validateCart_args:
94 ashish 12555 
  """
12556 
  Attributes:
559 chandransh 12557 
   - cartId
3557 rajveer 12558 
   - sourceId
94 ashish 12559 
  """
12560 
 
12561 
  thrift_spec = (
12562 
    None, # 0
559 chandransh 12563 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12564 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12565 
  )
12566 
 
3557 rajveer 12567 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12568 
    self.cartId = cartId
3557 rajveer 12569 
    self.sourceId = sourceId
94 ashish 12570 
 
12571 
  def read(self, iprot):
12572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12574 
      return
12575 
    iprot.readStructBegin()
12576 
    while True:
12577 
      (fname, ftype, fid) = iprot.readFieldBegin()
12578 
      if ftype == TType.STOP:
12579 
        break
12580 
      if fid == 1:
12581 
        if ftype == TType.I64:
559 chandransh 12582 
          self.cartId = iprot.readI64();
94 ashish 12583 
        else:
12584 
          iprot.skip(ftype)
3557 rajveer 12585 
      elif fid == 2:
12586 
        if ftype == TType.I64:
12587 
          self.sourceId = iprot.readI64();
12588 
        else:
12589 
          iprot.skip(ftype)
94 ashish 12590 
      else:
12591 
        iprot.skip(ftype)
12592 
      iprot.readFieldEnd()
12593 
    iprot.readStructEnd()
12594 
 
12595 
  def write(self, oprot):
12596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12598 
      return
559 chandransh 12599 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12600 
    if self.cartId is not None:
559 chandransh 12601 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12602 
      oprot.writeI64(self.cartId)
94 ashish 12603 
      oprot.writeFieldEnd()
3557 rajveer 12604 
    if self.sourceId is not None:
12605 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12606 
      oprot.writeI64(self.sourceId)
12607 
      oprot.writeFieldEnd()
94 ashish 12608 
    oprot.writeFieldStop()
12609 
    oprot.writeStructEnd()
12610 
 
3431 rajveer 12611 
  def validate(self):
12612 
    return
12613 
 
12614 
 
94 ashish 12615 
  def __repr__(self):
12616 
    L = ['%s=%r' % (key, value)
12617 
      for key, value in self.__dict__.iteritems()]
12618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12619 
 
12620 
  def __eq__(self, other):
12621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12622 
 
12623 
  def __ne__(self, other):
12624 
    return not (self == other)
12625 
 
559 chandransh 12626 
class validateCart_result:
94 ashish 12627 
  """
12628 
  Attributes:
12629 
   - success
575 chandransh 12630 
   - scex
94 ashish 12631 
  """
12632 
 
12633 
  thrift_spec = (
6736 amit.gupta 12634 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12635 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12636 
  )
12637 
 
575 chandransh 12638 
  def __init__(self, success=None, scex=None,):
94 ashish 12639 
    self.success = success
575 chandransh 12640 
    self.scex = scex
94 ashish 12641 
 
12642 
  def read(self, iprot):
12643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12645 
      return
12646 
    iprot.readStructBegin()
12647 
    while True:
12648 
      (fname, ftype, fid) = iprot.readFieldBegin()
12649 
      if ftype == TType.STOP:
12650 
        break
12651 
      if fid == 0:
6736 amit.gupta 12652 
        if ftype == TType.LIST:
12653 
          self.success = []
11592 amit.gupta 12654 
          (_etype170, _size167) = iprot.readListBegin()
12655 
          for _i171 in xrange(_size167):
12656 
            _elem172 = iprot.readString();
12657 
            self.success.append(_elem172)
6736 amit.gupta 12658 
          iprot.readListEnd()
94 ashish 12659 
        else:
12660 
          iprot.skip(ftype)
575 chandransh 12661 
      elif fid == 1:
12662 
        if ftype == TType.STRUCT:
12663 
          self.scex = ShoppingCartException()
12664 
          self.scex.read(iprot)
12665 
        else:
12666 
          iprot.skip(ftype)
94 ashish 12667 
      else:
12668 
        iprot.skip(ftype)
12669 
      iprot.readFieldEnd()
12670 
    iprot.readStructEnd()
12671 
 
12672 
  def write(self, oprot):
12673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12675 
      return
559 chandransh 12676 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12677 
    if self.success is not None:
6736 amit.gupta 12678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12679 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12680 
      for iter173 in self.success:
12681 
        oprot.writeString(iter173)
6736 amit.gupta 12682 
      oprot.writeListEnd()
94 ashish 12683 
      oprot.writeFieldEnd()
3431 rajveer 12684 
    if self.scex is not None:
575 chandransh 12685 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12686 
      self.scex.write(oprot)
12687 
      oprot.writeFieldEnd()
559 chandransh 12688 
    oprot.writeFieldStop()
12689 
    oprot.writeStructEnd()
12690 
 
3431 rajveer 12691 
  def validate(self):
12692 
    return
12693 
 
12694 
 
559 chandransh 12695 
  def __repr__(self):
12696 
    L = ['%s=%r' % (key, value)
12697 
      for key, value in self.__dict__.iteritems()]
12698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12699 
 
12700 
  def __eq__(self, other):
12701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12702 
 
12703 
  def __ne__(self, other):
12704 
    return not (self == other)
12705 
 
11980 amit.gupta 12706 
class validateCartWithDealerCoupon_args:
12707 
  """
12708 
  Attributes:
12709 
   - cartId
12710 
   - sourceId
12711 
   - dealCoupon
12712 
  """
12713 
 
12714 
  thrift_spec = (
12715 
    None, # 0
12716 
    (1, TType.I64, 'cartId', None, None, ), # 1
12717 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12718 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12719 
  )
12720 
 
12721 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12722 
    self.cartId = cartId
12723 
    self.sourceId = sourceId
12724 
    self.dealCoupon = dealCoupon
12725 
 
12726 
  def read(self, iprot):
12727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12729 
      return
12730 
    iprot.readStructBegin()
12731 
    while True:
12732 
      (fname, ftype, fid) = iprot.readFieldBegin()
12733 
      if ftype == TType.STOP:
12734 
        break
12735 
      if fid == 1:
12736 
        if ftype == TType.I64:
12737 
          self.cartId = iprot.readI64();
12738 
        else:
12739 
          iprot.skip(ftype)
12740 
      elif fid == 2:
12741 
        if ftype == TType.I64:
12742 
          self.sourceId = iprot.readI64();
12743 
        else:
12744 
          iprot.skip(ftype)
12745 
      elif fid == 3:
12746 
        if ftype == TType.STRING:
12747 
          self.dealCoupon = iprot.readString();
12748 
        else:
12749 
          iprot.skip(ftype)
12750 
      else:
12751 
        iprot.skip(ftype)
12752 
      iprot.readFieldEnd()
12753 
    iprot.readStructEnd()
12754 
 
12755 
  def write(self, oprot):
12756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12758 
      return
12759 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12760 
    if self.cartId is not None:
12761 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12762 
      oprot.writeI64(self.cartId)
12763 
      oprot.writeFieldEnd()
12764 
    if self.sourceId is not None:
12765 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12766 
      oprot.writeI64(self.sourceId)
12767 
      oprot.writeFieldEnd()
12768 
    if self.dealCoupon is not None:
12769 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12770 
      oprot.writeString(self.dealCoupon)
12771 
      oprot.writeFieldEnd()
12772 
    oprot.writeFieldStop()
12773 
    oprot.writeStructEnd()
12774 
 
12775 
  def validate(self):
12776 
    return
12777 
 
12778 
 
12779 
  def __repr__(self):
12780 
    L = ['%s=%r' % (key, value)
12781 
      for key, value in self.__dict__.iteritems()]
12782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12783 
 
12784 
  def __eq__(self, other):
12785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12786 
 
12787 
  def __ne__(self, other):
12788 
    return not (self == other)
12789 
 
12790 
class validateCartWithDealerCoupon_result:
12791 
  """
12792 
  Attributes:
12793 
   - success
12794 
   - scex
12795 
  """
12796 
 
12797 
  thrift_spec = (
12798 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12799 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12800 
  )
12801 
 
12802 
  def __init__(self, success=None, scex=None,):
12803 
    self.success = success
12804 
    self.scex = scex
12805 
 
12806 
  def read(self, iprot):
12807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12809 
      return
12810 
    iprot.readStructBegin()
12811 
    while True:
12812 
      (fname, ftype, fid) = iprot.readFieldBegin()
12813 
      if ftype == TType.STOP:
12814 
        break
12815 
      if fid == 0:
12816 
        if ftype == TType.LIST:
12817 
          self.success = []
12818 
          (_etype177, _size174) = iprot.readListBegin()
12819 
          for _i178 in xrange(_size174):
12820 
            _elem179 = iprot.readString();
12821 
            self.success.append(_elem179)
12822 
          iprot.readListEnd()
12823 
        else:
12824 
          iprot.skip(ftype)
12825 
      elif fid == 1:
12826 
        if ftype == TType.STRUCT:
12827 
          self.scex = ShoppingCartException()
12828 
          self.scex.read(iprot)
12829 
        else:
12830 
          iprot.skip(ftype)
12831 
      else:
12832 
        iprot.skip(ftype)
12833 
      iprot.readFieldEnd()
12834 
    iprot.readStructEnd()
12835 
 
12836 
  def write(self, oprot):
12837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12839 
      return
12840 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12841 
    if self.success is not None:
12842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12843 
      oprot.writeListBegin(TType.STRING, len(self.success))
12844 
      for iter180 in self.success:
12845 
        oprot.writeString(iter180)
12846 
      oprot.writeListEnd()
12847 
      oprot.writeFieldEnd()
12848 
    if self.scex is not None:
12849 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12850 
      self.scex.write(oprot)
12851 
      oprot.writeFieldEnd()
12852 
    oprot.writeFieldStop()
12853 
    oprot.writeStructEnd()
12854 
 
12855 
  def validate(self):
12856 
    return
12857 
 
12858 
 
12859 
  def __repr__(self):
12860 
    L = ['%s=%r' % (key, value)
12861 
      for key, value in self.__dict__.iteritems()]
12862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12863 
 
12864 
  def __eq__(self, other):
12865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12866 
 
12867 
  def __ne__(self, other):
12868 
    return not (self == other)
12869 
 
690 chandransh 12870 
class mergeCart_args:
575 chandransh 12871 
  """
12872 
  Attributes:
690 chandransh 12873 
   - fromCartId
12874 
   - toCartId
12875 
  """
12876 
 
12877 
  thrift_spec = (
12878 
    None, # 0
12879 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12880 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12881 
  )
12882 
 
12883 
  def __init__(self, fromCartId=None, toCartId=None,):
12884 
    self.fromCartId = fromCartId
12885 
    self.toCartId = toCartId
12886 
 
12887 
  def read(self, iprot):
12888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12890 
      return
12891 
    iprot.readStructBegin()
12892 
    while True:
12893 
      (fname, ftype, fid) = iprot.readFieldBegin()
12894 
      if ftype == TType.STOP:
12895 
        break
12896 
      if fid == 1:
12897 
        if ftype == TType.I64:
12898 
          self.fromCartId = iprot.readI64();
12899 
        else:
12900 
          iprot.skip(ftype)
12901 
      elif fid == 2:
12902 
        if ftype == TType.I64:
12903 
          self.toCartId = iprot.readI64();
12904 
        else:
12905 
          iprot.skip(ftype)
12906 
      else:
12907 
        iprot.skip(ftype)
12908 
      iprot.readFieldEnd()
12909 
    iprot.readStructEnd()
12910 
 
12911 
  def write(self, oprot):
12912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12914 
      return
12915 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12916 
    if self.fromCartId is not None:
690 chandransh 12917 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12918 
      oprot.writeI64(self.fromCartId)
12919 
      oprot.writeFieldEnd()
3431 rajveer 12920 
    if self.toCartId is not None:
690 chandransh 12921 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12922 
      oprot.writeI64(self.toCartId)
12923 
      oprot.writeFieldEnd()
12924 
    oprot.writeFieldStop()
12925 
    oprot.writeStructEnd()
12926 
 
3431 rajveer 12927 
  def validate(self):
12928 
    return
12929 
 
12930 
 
690 chandransh 12931 
  def __repr__(self):
12932 
    L = ['%s=%r' % (key, value)
12933 
      for key, value in self.__dict__.iteritems()]
12934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12935 
 
12936 
  def __eq__(self, other):
12937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12938 
 
12939 
  def __ne__(self, other):
12940 
    return not (self == other)
12941 
 
12942 
class mergeCart_result:
12943 
 
12944 
  thrift_spec = (
12945 
  )
12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      else:
12957 
        iprot.skip(ftype)
12958 
      iprot.readFieldEnd()
12959 
    iprot.readStructEnd()
12960 
 
12961 
  def write(self, oprot):
12962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12964 
      return
12965 
    oprot.writeStructBegin('mergeCart_result')
12966 
    oprot.writeFieldStop()
12967 
    oprot.writeStructEnd()
12968 
 
3431 rajveer 12969 
  def validate(self):
12970 
    return
12971 
 
12972 
 
690 chandransh 12973 
  def __repr__(self):
12974 
    L = ['%s=%r' % (key, value)
12975 
      for key, value in self.__dict__.iteritems()]
12976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12977 
 
12978 
  def __eq__(self, other):
12979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12980 
 
12981 
  def __ne__(self, other):
12982 
    return not (self == other)
12983 
 
12984 
class checkOut_args:
12985 
  """
12986 
  Attributes:
575 chandransh 12987 
   - cartId
12988 
  """
12989 
 
12990 
  thrift_spec = (
12991 
    None, # 0
12992 
    (1, TType.I64, 'cartId', None, None, ), # 1
12993 
  )
12994 
 
12995 
  def __init__(self, cartId=None,):
12996 
    self.cartId = cartId
12997 
 
12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
13007 
      if fid == 1:
13008 
        if ftype == TType.I64:
13009 
          self.cartId = iprot.readI64();
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      else:
13013 
        iprot.skip(ftype)
13014 
      iprot.readFieldEnd()
13015 
    iprot.readStructEnd()
13016 
 
13017 
  def write(self, oprot):
13018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13020 
      return
690 chandransh 13021 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 13022 
    if self.cartId is not None:
575 chandransh 13023 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13024 
      oprot.writeI64(self.cartId)
13025 
      oprot.writeFieldEnd()
13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
3431 rajveer 13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
575 chandransh 13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
690 chandransh 13044 
class checkOut_result:
575 chandransh 13045 
  """
13046 
  Attributes:
13047 
   - success
13048 
   - scex
13049 
  """
13050 
 
13051 
  thrift_spec = (
13052 
    (0, TType.BOOL, 'success', None, None, ), # 0
13053 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13054 
  )
13055 
 
13056 
  def __init__(self, success=None, scex=None,):
13057 
    self.success = success
13058 
    self.scex = scex
13059 
 
13060 
  def read(self, iprot):
13061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13063 
      return
13064 
    iprot.readStructBegin()
13065 
    while True:
13066 
      (fname, ftype, fid) = iprot.readFieldBegin()
13067 
      if ftype == TType.STOP:
13068 
        break
13069 
      if fid == 0:
13070 
        if ftype == TType.BOOL:
13071 
          self.success = iprot.readBool();
13072 
        else:
13073 
          iprot.skip(ftype)
13074 
      elif fid == 1:
13075 
        if ftype == TType.STRUCT:
13076 
          self.scex = ShoppingCartException()
13077 
          self.scex.read(iprot)
13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      else:
13081 
        iprot.skip(ftype)
13082 
      iprot.readFieldEnd()
13083 
    iprot.readStructEnd()
13084 
 
13085 
  def write(self, oprot):
13086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13088 
      return
690 chandransh 13089 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13090 
    if self.success is not None:
575 chandransh 13091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13092 
      oprot.writeBool(self.success)
13093 
      oprot.writeFieldEnd()
3431 rajveer 13094 
    if self.scex is not None:
575 chandransh 13095 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13096 
      self.scex.write(oprot)
13097 
      oprot.writeFieldEnd()
13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
3431 rajveer 13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
575 chandransh 13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
690 chandransh 13116 
class resetCart_args:
559 chandransh 13117 
  """
13118 
  Attributes:
690 chandransh 13119 
   - cartId
13120 
   - items
559 chandransh 13121 
  """
13122 
 
13123 
  thrift_spec = (
13124 
    None, # 0
690 chandransh 13125 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13126 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13127 
  )
13128 
 
690 chandransh 13129 
  def __init__(self, cartId=None, items=None,):
13130 
    self.cartId = cartId
13131 
    self.items = items
559 chandransh 13132 
 
13133 
  def read(self, iprot):
13134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13136 
      return
13137 
    iprot.readStructBegin()
13138 
    while True:
13139 
      (fname, ftype, fid) = iprot.readFieldBegin()
13140 
      if ftype == TType.STOP:
13141 
        break
13142 
      if fid == 1:
13143 
        if ftype == TType.I64:
690 chandransh 13144 
          self.cartId = iprot.readI64();
559 chandransh 13145 
        else:
13146 
          iprot.skip(ftype)
13147 
      elif fid == 2:
690 chandransh 13148 
        if ftype == TType.MAP:
13149 
          self.items = {}
11980 amit.gupta 13150 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13151 
          for _i185 in xrange(_size181):
13152 
            _key186 = iprot.readI64();
13153 
            _val187 = iprot.readDouble();
13154 
            self.items[_key186] = _val187
690 chandransh 13155 
          iprot.readMapEnd()
559 chandransh 13156 
        else:
13157 
          iprot.skip(ftype)
13158 
      else:
13159 
        iprot.skip(ftype)
13160 
      iprot.readFieldEnd()
13161 
    iprot.readStructEnd()
13162 
 
13163 
  def write(self, oprot):
13164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13166 
      return
690 chandransh 13167 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13168 
    if self.cartId is not None:
690 chandransh 13169 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13170 
      oprot.writeI64(self.cartId)
94 ashish 13171 
      oprot.writeFieldEnd()
3431 rajveer 13172 
    if self.items is not None:
690 chandransh 13173 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13174 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13175 
      for kiter188,viter189 in self.items.items():
13176 
        oprot.writeI64(kiter188)
13177 
        oprot.writeDouble(viter189)
690 chandransh 13178 
      oprot.writeMapEnd()
559 chandransh 13179 
      oprot.writeFieldEnd()
94 ashish 13180 
    oprot.writeFieldStop()
13181 
    oprot.writeStructEnd()
13182 
 
3431 rajveer 13183 
  def validate(self):
13184 
    return
13185 
 
13186 
 
94 ashish 13187 
  def __repr__(self):
13188 
    L = ['%s=%r' % (key, value)
13189 
      for key, value in self.__dict__.iteritems()]
13190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13191 
 
13192 
  def __eq__(self, other):
13193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13194 
 
13195 
  def __ne__(self, other):
13196 
    return not (self == other)
13197 
 
690 chandransh 13198 
class resetCart_result:
13199 
  """
13200 
  Attributes:
13201 
   - success
13202 
   - scex
13203 
  """
559 chandransh 13204 
 
13205 
  thrift_spec = (
690 chandransh 13206 
    (0, TType.BOOL, 'success', None, None, ), # 0
13207 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13208 
  )
13209 
 
690 chandransh 13210 
  def __init__(self, success=None, scex=None,):
13211 
    self.success = success
13212 
    self.scex = scex
13213 
 
559 chandransh 13214 
  def read(self, iprot):
13215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13217 
      return
13218 
    iprot.readStructBegin()
13219 
    while True:
13220 
      (fname, ftype, fid) = iprot.readFieldBegin()
13221 
      if ftype == TType.STOP:
13222 
        break
690 chandransh 13223 
      if fid == 0:
13224 
        if ftype == TType.BOOL:
13225 
          self.success = iprot.readBool();
13226 
        else:
13227 
          iprot.skip(ftype)
13228 
      elif fid == 1:
13229 
        if ftype == TType.STRUCT:
13230 
          self.scex = ShoppingCartException()
13231 
          self.scex.read(iprot)
13232 
        else:
13233 
          iprot.skip(ftype)
559 chandransh 13234 
      else:
13235 
        iprot.skip(ftype)
13236 
      iprot.readFieldEnd()
13237 
    iprot.readStructEnd()
13238 
 
13239 
  def write(self, oprot):
13240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13242 
      return
690 chandransh 13243 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13244 
    if self.success is not None:
690 chandransh 13245 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13246 
      oprot.writeBool(self.success)
13247 
      oprot.writeFieldEnd()
3431 rajveer 13248 
    if self.scex is not None:
690 chandransh 13249 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13250 
      self.scex.write(oprot)
13251 
      oprot.writeFieldEnd()
559 chandransh 13252 
    oprot.writeFieldStop()
13253 
    oprot.writeStructEnd()
13254 
 
3431 rajveer 13255 
  def validate(self):
13256 
    return
13257 
 
13258 
 
559 chandransh 13259 
  def __repr__(self):
13260 
    L = ['%s=%r' % (key, value)
13261 
      for key, value in self.__dict__.iteritems()]
13262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13263 
 
13264 
  def __eq__(self, other):
13265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13266 
 
13267 
  def __ne__(self, other):
13268 
    return not (self == other)
13269 
 
2981 rajveer 13270 
class getUserCount_args:
94 ashish 13271 
  """
13272 
  Attributes:
2981 rajveer 13273 
   - userType
559 chandransh 13274 
  """
13275 
 
13276 
  thrift_spec = (
13277 
    None, # 0
2981 rajveer 13278 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13279 
  )
13280 
 
2981 rajveer 13281 
  def __init__(self, userType=None,):
13282 
    self.userType = userType
559 chandransh 13283 
 
13284 
  def read(self, iprot):
13285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13287 
      return
13288 
    iprot.readStructBegin()
13289 
    while True:
13290 
      (fname, ftype, fid) = iprot.readFieldBegin()
13291 
      if ftype == TType.STOP:
13292 
        break
13293 
      if fid == 1:
2981 rajveer 13294 
        if ftype == TType.I32:
13295 
          self.userType = iprot.readI32();
559 chandransh 13296 
        else:
13297 
          iprot.skip(ftype)
13298 
      else:
13299 
        iprot.skip(ftype)
13300 
      iprot.readFieldEnd()
13301 
    iprot.readStructEnd()
13302 
 
13303 
  def write(self, oprot):
13304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13306 
      return
2981 rajveer 13307 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13308 
    if self.userType is not None:
2981 rajveer 13309 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13310 
      oprot.writeI32(self.userType)
559 chandransh 13311 
      oprot.writeFieldEnd()
13312 
    oprot.writeFieldStop()
13313 
    oprot.writeStructEnd()
13314 
 
3431 rajveer 13315 
  def validate(self):
13316 
    return
13317 
 
13318 
 
559 chandransh 13319 
  def __repr__(self):
13320 
    L = ['%s=%r' % (key, value)
13321 
      for key, value in self.__dict__.iteritems()]
13322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13323 
 
13324 
  def __eq__(self, other):
13325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13326 
 
13327 
  def __ne__(self, other):
13328 
    return not (self == other)
13329 
 
2981 rajveer 13330 
class getUserCount_result:
94 ashish 13331 
  """
13332 
  Attributes:
13333 
   - success
13334 
  """
13335 
 
13336 
  thrift_spec = (
2981 rajveer 13337 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13338 
  )
13339 
 
2981 rajveer 13340 
  def __init__(self, success=None,):
94 ashish 13341 
    self.success = success
13342 
 
13343 
  def read(self, iprot):
13344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13346 
      return
13347 
    iprot.readStructBegin()
13348 
    while True:
13349 
      (fname, ftype, fid) = iprot.readFieldBegin()
13350 
      if ftype == TType.STOP:
13351 
        break
13352 
      if fid == 0:
2981 rajveer 13353 
        if ftype == TType.I64:
13354 
          self.success = iprot.readI64();
94 ashish 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('getUserCount_result')
3431 rajveer 13367 
    if self.success is not None:
2981 rajveer 13368 
      oprot.writeFieldBegin('success', TType.I64, 0)
13369 
      oprot.writeI64(self.success)
94 ashish 13370 
      oprot.writeFieldEnd()
13371 
    oprot.writeFieldStop()
13372 
    oprot.writeStructEnd()
13373 
 
3431 rajveer 13374 
  def validate(self):
13375 
    return
13376 
 
13377 
 
94 ashish 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 getAllUsers_args:
94 ashish 13390 
  """
13391 
  Attributes:
2981 rajveer 13392 
   - userType
13393 
   - startDate
13394 
   - endDate
94 ashish 13395 
  """
13396 
 
13397 
  thrift_spec = (
13398 
    None, # 0
2981 rajveer 13399 
    (1, TType.I32, 'userType', None, None, ), # 1
13400 
    (2, TType.I64, 'startDate', None, None, ), # 2
13401 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13402 
  )
13403 
 
2981 rajveer 13404 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13405 
    self.userType = userType
13406 
    self.startDate = startDate
13407 
    self.endDate = endDate
94 ashish 13408 
 
13409 
  def read(self, iprot):
13410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13412 
      return
13413 
    iprot.readStructBegin()
13414 
    while True:
13415 
      (fname, ftype, fid) = iprot.readFieldBegin()
13416 
      if ftype == TType.STOP:
13417 
        break
13418 
      if fid == 1:
2981 rajveer 13419 
        if ftype == TType.I32:
13420 
          self.userType = iprot.readI32();
94 ashish 13421 
        else:
13422 
          iprot.skip(ftype)
13423 
      elif fid == 2:
559 chandransh 13424 
        if ftype == TType.I64:
2981 rajveer 13425 
          self.startDate = iprot.readI64();
94 ashish 13426 
        else:
13427 
          iprot.skip(ftype)
2981 rajveer 13428 
      elif fid == 3:
13429 
        if ftype == TType.I64:
13430 
          self.endDate = iprot.readI64();
13431 
        else:
13432 
          iprot.skip(ftype)
94 ashish 13433 
      else:
13434 
        iprot.skip(ftype)
13435 
      iprot.readFieldEnd()
13436 
    iprot.readStructEnd()
13437 
 
13438 
  def write(self, oprot):
13439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13441 
      return
2981 rajveer 13442 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13443 
    if self.userType is not None:
2981 rajveer 13444 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13445 
      oprot.writeI32(self.userType)
94 ashish 13446 
      oprot.writeFieldEnd()
3431 rajveer 13447 
    if self.startDate is not None:
2981 rajveer 13448 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13449 
      oprot.writeI64(self.startDate)
94 ashish 13450 
      oprot.writeFieldEnd()
3431 rajveer 13451 
    if self.endDate is not None:
2981 rajveer 13452 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13453 
      oprot.writeI64(self.endDate)
13454 
      oprot.writeFieldEnd()
94 ashish 13455 
    oprot.writeFieldStop()
13456 
    oprot.writeStructEnd()
13457 
 
3431 rajveer 13458 
  def validate(self):
13459 
    return
13460 
 
13461 
 
94 ashish 13462 
  def __repr__(self):
13463 
    L = ['%s=%r' % (key, value)
13464 
      for key, value in self.__dict__.iteritems()]
13465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13466 
 
13467 
  def __eq__(self, other):
13468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13469 
 
13470 
  def __ne__(self, other):
13471 
    return not (self == other)
13472 
 
2981 rajveer 13473 
class getAllUsers_result:
94 ashish 13474 
  """
13475 
  Attributes:
13476 
   - success
13477 
  """
13478 
 
13479 
  thrift_spec = (
2981 rajveer 13480 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13481 
  )
13482 
 
2981 rajveer 13483 
  def __init__(self, success=None,):
94 ashish 13484 
    self.success = success
13485 
 
13486 
  def read(self, iprot):
13487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13489 
      return
13490 
    iprot.readStructBegin()
13491 
    while True:
13492 
      (fname, ftype, fid) = iprot.readFieldBegin()
13493 
      if ftype == TType.STOP:
13494 
        break
13495 
      if fid == 0:
2981 rajveer 13496 
        if ftype == TType.LIST:
13497 
          self.success = []
11980 amit.gupta 13498 
          (_etype193, _size190) = iprot.readListBegin()
13499 
          for _i194 in xrange(_size190):
13500 
            _elem195 = User()
13501 
            _elem195.read(iprot)
13502 
            self.success.append(_elem195)
2981 rajveer 13503 
          iprot.readListEnd()
94 ashish 13504 
        else:
13505 
          iprot.skip(ftype)
13506 
      else:
13507 
        iprot.skip(ftype)
13508 
      iprot.readFieldEnd()
13509 
    iprot.readStructEnd()
13510 
 
13511 
  def write(self, oprot):
13512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13514 
      return
2981 rajveer 13515 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13516 
    if self.success is not None:
2981 rajveer 13517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13519 
      for iter196 in self.success:
13520 
        iter196.write(oprot)
2981 rajveer 13521 
      oprot.writeListEnd()
94 ashish 13522 
      oprot.writeFieldEnd()
13523 
    oprot.writeFieldStop()
13524 
    oprot.writeStructEnd()
13525 
 
3431 rajveer 13526 
  def validate(self):
13527 
    return
13528 
 
13529 
 
94 ashish 13530 
  def __repr__(self):
13531 
    L = ['%s=%r' % (key, value)
13532 
      for key, value in self.__dict__.iteritems()]
13533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13534 
 
13535 
  def __eq__(self, other):
13536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13537 
 
13538 
  def __ne__(self, other):
13539 
    return not (self == other)
13540 
 
2981 rajveer 13541 
class getMyResearchItems_args:
559 chandransh 13542 
  """
13543 
  Attributes:
772 rajveer 13544 
   - userId
559 chandransh 13545 
  """
13546 
 
13547 
  thrift_spec = (
13548 
    None, # 0
772 rajveer 13549 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13550 
  )
13551 
 
772 rajveer 13552 
  def __init__(self, userId=None,):
13553 
    self.userId = userId
559 chandransh 13554 
 
13555 
  def read(self, iprot):
13556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13558 
      return
13559 
    iprot.readStructBegin()
13560 
    while True:
13561 
      (fname, ftype, fid) = iprot.readFieldBegin()
13562 
      if ftype == TType.STOP:
13563 
        break
13564 
      if fid == 1:
13565 
        if ftype == TType.I64:
772 rajveer 13566 
          self.userId = iprot.readI64();
559 chandransh 13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      else:
13570 
        iprot.skip(ftype)
13571 
      iprot.readFieldEnd()
13572 
    iprot.readStructEnd()
13573 
 
13574 
  def write(self, oprot):
13575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13577 
      return
2981 rajveer 13578 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13579 
    if self.userId is not None:
772 rajveer 13580 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13581 
      oprot.writeI64(self.userId)
559 chandransh 13582 
      oprot.writeFieldEnd()
13583 
    oprot.writeFieldStop()
13584 
    oprot.writeStructEnd()
13585 
 
3431 rajveer 13586 
  def validate(self):
13587 
    return
13588 
 
13589 
 
559 chandransh 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 getMyResearchItems_result:
559 chandransh 13602 
  """
13603 
  Attributes:
130 ashish 13604 
   - success
559 chandransh 13605 
   - scx
130 ashish 13606 
  """
13607 
 
13608 
  thrift_spec = (
2981 rajveer 13609 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13610 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13611 
  )
13612 
 
559 chandransh 13613 
  def __init__(self, success=None, scx=None,):
130 ashish 13614 
    self.success = success
559 chandransh 13615 
    self.scx = scx
130 ashish 13616 
 
13617 
  def read(self, iprot):
13618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13620 
      return
13621 
    iprot.readStructBegin()
13622 
    while True:
13623 
      (fname, ftype, fid) = iprot.readFieldBegin()
13624 
      if ftype == TType.STOP:
13625 
        break
13626 
      if fid == 0:
2981 rajveer 13627 
        if ftype == TType.LIST:
13628 
          self.success = []
11980 amit.gupta 13629 
          (_etype200, _size197) = iprot.readListBegin()
13630 
          for _i201 in xrange(_size197):
13631 
            _elem202 = iprot.readI64();
13632 
            self.success.append(_elem202)
2981 rajveer 13633 
          iprot.readListEnd()
130 ashish 13634 
        else:
13635 
          iprot.skip(ftype)
13636 
      elif fid == 1:
13637 
        if ftype == TType.STRUCT:
559 chandransh 13638 
          self.scx = WidgetException()
13639 
          self.scx.read(iprot)
130 ashish 13640 
        else:
13641 
          iprot.skip(ftype)
13642 
      else:
13643 
        iprot.skip(ftype)
13644 
      iprot.readFieldEnd()
13645 
    iprot.readStructEnd()
13646 
 
13647 
  def write(self, oprot):
13648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13650 
      return
2981 rajveer 13651 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13652 
    if self.success is not None:
2981 rajveer 13653 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13654 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13655 
      for iter203 in self.success:
13656 
        oprot.writeI64(iter203)
2981 rajveer 13657 
      oprot.writeListEnd()
130 ashish 13658 
      oprot.writeFieldEnd()
3431 rajveer 13659 
    if self.scx is not None:
559 chandransh 13660 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13661 
      self.scx.write(oprot)
130 ashish 13662 
      oprot.writeFieldEnd()
13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
3431 rajveer 13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
130 ashish 13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
2981 rajveer 13681 
class updateMyResearch_args:
130 ashish 13682 
  """
13683 
  Attributes:
2981 rajveer 13684 
   - userId
13685 
   - itemId
130 ashish 13686 
  """
13687 
 
13688 
  thrift_spec = (
13689 
    None, # 0
2981 rajveer 13690 
    (1, TType.I64, 'userId', None, None, ), # 1
13691 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13692 
  )
13693 
 
2981 rajveer 13694 
  def __init__(self, userId=None, itemId=None,):
13695 
    self.userId = userId
13696 
    self.itemId = itemId
130 ashish 13697 
 
13698 
  def read(self, iprot):
13699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13701 
      return
13702 
    iprot.readStructBegin()
13703 
    while True:
13704 
      (fname, ftype, fid) = iprot.readFieldBegin()
13705 
      if ftype == TType.STOP:
13706 
        break
13707 
      if fid == 1:
559 chandransh 13708 
        if ftype == TType.I64:
2981 rajveer 13709 
          self.userId = iprot.readI64();
130 ashish 13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      elif fid == 2:
559 chandransh 13713 
        if ftype == TType.I64:
2981 rajveer 13714 
          self.itemId = iprot.readI64();
559 chandransh 13715 
        else:
13716 
          iprot.skip(ftype)
130 ashish 13717 
      else:
13718 
        iprot.skip(ftype)
13719 
      iprot.readFieldEnd()
13720 
    iprot.readStructEnd()
13721 
 
13722 
  def write(self, oprot):
13723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13725 
      return
2981 rajveer 13726 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13727 
    if self.userId is not None:
2981 rajveer 13728 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13729 
      oprot.writeI64(self.userId)
130 ashish 13730 
      oprot.writeFieldEnd()
3431 rajveer 13731 
    if self.itemId is not None:
2981 rajveer 13732 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13733 
      oprot.writeI64(self.itemId)
130 ashish 13734 
      oprot.writeFieldEnd()
13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
3431 rajveer 13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
130 ashish 13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
2981 rajveer 13753 
class updateMyResearch_result:
13754 
  """
13755 
  Attributes:
13756 
   - success
13757 
   - scx
13758 
  """
559 chandransh 13759 
 
13760 
  thrift_spec = (
2981 rajveer 13761 
    (0, TType.BOOL, 'success', None, None, ), # 0
13762 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13763 
  )
13764 
 
2981 rajveer 13765 
  def __init__(self, success=None, scx=None,):
13766 
    self.success = success
13767 
    self.scx = scx
13768 
 
559 chandransh 13769 
  def read(self, iprot):
13770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13772 
      return
13773 
    iprot.readStructBegin()
13774 
    while True:
13775 
      (fname, ftype, fid) = iprot.readFieldBegin()
13776 
      if ftype == TType.STOP:
13777 
        break
2981 rajveer 13778 
      if fid == 0:
13779 
        if ftype == TType.BOOL:
13780 
          self.success = iprot.readBool();
13781 
        else:
13782 
          iprot.skip(ftype)
13783 
      elif fid == 1:
13784 
        if ftype == TType.STRUCT:
13785 
          self.scx = WidgetException()
13786 
          self.scx.read(iprot)
13787 
        else:
13788 
          iprot.skip(ftype)
559 chandransh 13789 
      else:
13790 
        iprot.skip(ftype)
13791 
      iprot.readFieldEnd()
13792 
    iprot.readStructEnd()
13793 
 
13794 
  def write(self, oprot):
13795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13797 
      return
2981 rajveer 13798 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13799 
    if self.success is not None:
2981 rajveer 13800 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13801 
      oprot.writeBool(self.success)
13802 
      oprot.writeFieldEnd()
3431 rajveer 13803 
    if self.scx is not None:
2981 rajveer 13804 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13805 
      self.scx.write(oprot)
13806 
      oprot.writeFieldEnd()
559 chandransh 13807 
    oprot.writeFieldStop()
13808 
    oprot.writeStructEnd()
13809 
 
3431 rajveer 13810 
  def validate(self):
13811 
    return
13812 
 
13813 
 
559 chandransh 13814 
  def __repr__(self):
13815 
    L = ['%s=%r' % (key, value)
13816 
      for key, value in self.__dict__.iteritems()]
13817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13818 
 
13819 
  def __eq__(self, other):
13820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13821 
 
13822 
  def __ne__(self, other):
13823 
    return not (self == other)
13824 
 
2981 rajveer 13825 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13826 
  """
13827 
  Attributes:
2981 rajveer 13828 
   - userId
13829 
   - itemId
1596 ankur.sing 13830 
  """
559 chandransh 13831 
 
1596 ankur.sing 13832 
  thrift_spec = (
13833 
    None, # 0
2981 rajveer 13834 
    (1, TType.I64, 'userId', None, None, ), # 1
13835 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13836 
  )
13837 
 
2981 rajveer 13838 
  def __init__(self, userId=None, itemId=None,):
13839 
    self.userId = userId
13840 
    self.itemId = itemId
1596 ankur.sing 13841 
 
13842 
  def read(self, iprot):
13843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13845 
      return
13846 
    iprot.readStructBegin()
13847 
    while True:
13848 
      (fname, ftype, fid) = iprot.readFieldBegin()
13849 
      if ftype == TType.STOP:
13850 
        break
13851 
      if fid == 1:
2981 rajveer 13852 
        if ftype == TType.I64:
13853 
          self.userId = iprot.readI64();
1596 ankur.sing 13854 
        else:
13855 
          iprot.skip(ftype)
2981 rajveer 13856 
      elif fid == 2:
13857 
        if ftype == TType.I64:
13858 
          self.itemId = iprot.readI64();
13859 
        else:
13860 
          iprot.skip(ftype)
1596 ankur.sing 13861 
      else:
13862 
        iprot.skip(ftype)
13863 
      iprot.readFieldEnd()
13864 
    iprot.readStructEnd()
13865 
 
13866 
  def write(self, oprot):
13867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13869 
      return
2981 rajveer 13870 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13871 
    if self.userId is not None:
2981 rajveer 13872 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13873 
      oprot.writeI64(self.userId)
1596 ankur.sing 13874 
      oprot.writeFieldEnd()
3431 rajveer 13875 
    if self.itemId is not None:
2981 rajveer 13876 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13877 
      oprot.writeI64(self.itemId)
13878 
      oprot.writeFieldEnd()
1596 ankur.sing 13879 
    oprot.writeFieldStop()
13880 
    oprot.writeStructEnd()
13881 
 
3431 rajveer 13882 
  def validate(self):
13883 
    return
13884 
 
13885 
 
1596 ankur.sing 13886 
  def __repr__(self):
13887 
    L = ['%s=%r' % (key, value)
13888 
      for key, value in self.__dict__.iteritems()]
13889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13890 
 
13891 
  def __eq__(self, other):
13892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13893 
 
13894 
  def __ne__(self, other):
13895 
    return not (self == other)
13896 
 
2981 rajveer 13897 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13898 
  """
13899 
  Attributes:
2981 rajveer 13900 
   - scx
1596 ankur.sing 13901 
  """
13902 
 
13903 
  thrift_spec = (
2981 rajveer 13904 
    None, # 0
13905 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13906 
  )
13907 
 
2981 rajveer 13908 
  def __init__(self, scx=None,):
13909 
    self.scx = scx
1596 ankur.sing 13910 
 
13911 
  def read(self, iprot):
13912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13914 
      return
13915 
    iprot.readStructBegin()
13916 
    while True:
13917 
      (fname, ftype, fid) = iprot.readFieldBegin()
13918 
      if ftype == TType.STOP:
13919 
        break
2981 rajveer 13920 
      if fid == 1:
13921 
        if ftype == TType.STRUCT:
13922 
          self.scx = WidgetException()
13923 
          self.scx.read(iprot)
1596 ankur.sing 13924 
        else:
13925 
          iprot.skip(ftype)
13926 
      else:
13927 
        iprot.skip(ftype)
13928 
      iprot.readFieldEnd()
13929 
    iprot.readStructEnd()
13930 
 
13931 
  def write(self, oprot):
13932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13934 
      return
2981 rajveer 13935 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13936 
    if self.scx is not None:
2981 rajveer 13937 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13938 
      self.scx.write(oprot)
1596 ankur.sing 13939 
      oprot.writeFieldEnd()
13940 
    oprot.writeFieldStop()
13941 
    oprot.writeStructEnd()
13942 
 
3431 rajveer 13943 
  def validate(self):
13944 
    return
13945 
 
13946 
 
1596 ankur.sing 13947 
  def __repr__(self):
13948 
    L = ['%s=%r' % (key, value)
13949 
      for key, value in self.__dict__.iteritems()]
13950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13951 
 
13952 
  def __eq__(self, other):
13953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13954 
 
13955 
  def __ne__(self, other):
13956 
    return not (self == other)
13957 
 
2981 rajveer 13958 
class getBrowseHistoryItems_args:
1673 ankur.sing 13959 
  """
13960 
  Attributes:
2981 rajveer 13961 
   - userId
1673 ankur.sing 13962 
  """
1596 ankur.sing 13963 
 
1673 ankur.sing 13964 
  thrift_spec = (
13965 
    None, # 0
2981 rajveer 13966 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13967 
  )
13968 
 
2981 rajveer 13969 
  def __init__(self, userId=None,):
13970 
    self.userId = userId
1673 ankur.sing 13971 
 
13972 
  def read(self, iprot):
13973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13975 
      return
13976 
    iprot.readStructBegin()
13977 
    while True:
13978 
      (fname, ftype, fid) = iprot.readFieldBegin()
13979 
      if ftype == TType.STOP:
13980 
        break
13981 
      if fid == 1:
1891 ankur.sing 13982 
        if ftype == TType.I64:
2981 rajveer 13983 
          self.userId = iprot.readI64();
1891 ankur.sing 13984 
        else:
13985 
          iprot.skip(ftype)
1673 ankur.sing 13986 
      else:
13987 
        iprot.skip(ftype)
13988 
      iprot.readFieldEnd()
13989 
    iprot.readStructEnd()
13990 
 
13991 
  def write(self, oprot):
13992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13994 
      return
2981 rajveer 13995 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13996 
    if self.userId is not None:
2981 rajveer 13997 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13998 
      oprot.writeI64(self.userId)
1673 ankur.sing 13999 
      oprot.writeFieldEnd()
14000 
    oprot.writeFieldStop()
14001 
    oprot.writeStructEnd()
14002 
 
3431 rajveer 14003 
  def validate(self):
14004 
    return
14005 
 
14006 
 
1673 ankur.sing 14007 
  def __repr__(self):
14008 
    L = ['%s=%r' % (key, value)
14009 
      for key, value in self.__dict__.iteritems()]
14010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14011 
 
14012 
  def __eq__(self, other):
14013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14014 
 
14015 
  def __ne__(self, other):
14016 
    return not (self == other)
14017 
 
2981 rajveer 14018 
class getBrowseHistoryItems_result:
1673 ankur.sing 14019 
  """
14020 
  Attributes:
14021 
   - success
2981 rajveer 14022 
   - scx
1673 ankur.sing 14023 
  """
14024 
 
14025 
  thrift_spec = (
2981 rajveer 14026 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14027 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 14028 
  )
14029 
 
2981 rajveer 14030 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 14031 
    self.success = success
2981 rajveer 14032 
    self.scx = scx
1673 ankur.sing 14033 
 
14034 
  def read(self, iprot):
14035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14037 
      return
14038 
    iprot.readStructBegin()
14039 
    while True:
14040 
      (fname, ftype, fid) = iprot.readFieldBegin()
14041 
      if ftype == TType.STOP:
14042 
        break
14043 
      if fid == 0:
14044 
        if ftype == TType.LIST:
14045 
          self.success = []
11980 amit.gupta 14046 
          (_etype207, _size204) = iprot.readListBegin()
14047 
          for _i208 in xrange(_size204):
14048 
            _elem209 = iprot.readI64();
14049 
            self.success.append(_elem209)
1673 ankur.sing 14050 
          iprot.readListEnd()
14051 
        else:
14052 
          iprot.skip(ftype)
2981 rajveer 14053 
      elif fid == 1:
14054 
        if ftype == TType.STRUCT:
14055 
          self.scx = WidgetException()
14056 
          self.scx.read(iprot)
14057 
        else:
14058 
          iprot.skip(ftype)
1673 ankur.sing 14059 
      else:
14060 
        iprot.skip(ftype)
14061 
      iprot.readFieldEnd()
14062 
    iprot.readStructEnd()
14063 
 
14064 
  def write(self, oprot):
14065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14067 
      return
2981 rajveer 14068 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14069 
    if self.success is not None:
1673 ankur.sing 14070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14071 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14072 
      for iter210 in self.success:
14073 
        oprot.writeI64(iter210)
1673 ankur.sing 14074 
      oprot.writeListEnd()
14075 
      oprot.writeFieldEnd()
3431 rajveer 14076 
    if self.scx is not None:
2981 rajveer 14077 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14078 
      self.scx.write(oprot)
2642 varun.gupt 14079 
      oprot.writeFieldEnd()
14080 
    oprot.writeFieldStop()
14081 
    oprot.writeStructEnd()
14082 
 
3431 rajveer 14083 
  def validate(self):
14084 
    return
14085 
 
14086 
 
2642 varun.gupt 14087 
  def __repr__(self):
14088 
    L = ['%s=%r' % (key, value)
14089 
      for key, value in self.__dict__.iteritems()]
14090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14091 
 
14092 
  def __eq__(self, other):
14093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14094 
 
14095 
  def __ne__(self, other):
14096 
    return not (self == other)
14097 
 
2981 rajveer 14098 
class updateBrowseHistory_args:
2642 varun.gupt 14099 
  """
14100 
  Attributes:
2981 rajveer 14101 
   - userId
14102 
   - itemId
2642 varun.gupt 14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    None, # 0
2981 rajveer 14107 
    (1, TType.I64, 'userId', None, None, ), # 1
14108 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14109 
  )
14110 
 
2981 rajveer 14111 
  def __init__(self, userId=None, itemId=None,):
14112 
    self.userId = userId
14113 
    self.itemId = itemId
2642 varun.gupt 14114 
 
14115 
  def read(self, iprot):
14116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14118 
      return
14119 
    iprot.readStructBegin()
14120 
    while True:
14121 
      (fname, ftype, fid) = iprot.readFieldBegin()
14122 
      if ftype == TType.STOP:
14123 
        break
14124 
      if fid == 1:
14125 
        if ftype == TType.I64:
2981 rajveer 14126 
          self.userId = iprot.readI64();
2642 varun.gupt 14127 
        else:
14128 
          iprot.skip(ftype)
14129 
      elif fid == 2:
14130 
        if ftype == TType.I64:
2981 rajveer 14131 
          self.itemId = iprot.readI64();
2642 varun.gupt 14132 
        else:
14133 
          iprot.skip(ftype)
14134 
      else:
14135 
        iprot.skip(ftype)
14136 
      iprot.readFieldEnd()
14137 
    iprot.readStructEnd()
14138 
 
14139 
  def write(self, oprot):
14140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14142 
      return
2981 rajveer 14143 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14144 
    if self.userId is not None:
2981 rajveer 14145 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14146 
      oprot.writeI64(self.userId)
2642 varun.gupt 14147 
      oprot.writeFieldEnd()
3431 rajveer 14148 
    if self.itemId is not None:
2981 rajveer 14149 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14150 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14151 
      oprot.writeFieldEnd()
14152 
    oprot.writeFieldStop()
14153 
    oprot.writeStructEnd()
14154 
 
3431 rajveer 14155 
  def validate(self):
14156 
    return
14157 
 
14158 
 
2642 varun.gupt 14159 
  def __repr__(self):
14160 
    L = ['%s=%r' % (key, value)
14161 
      for key, value in self.__dict__.iteritems()]
14162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14163 
 
14164 
  def __eq__(self, other):
14165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14166 
 
14167 
  def __ne__(self, other):
14168 
    return not (self == other)
14169 
 
2981 rajveer 14170 
class updateBrowseHistory_result:
2642 varun.gupt 14171 
 
14172 
  thrift_spec = (
14173 
  )
14174 
 
14175 
  def read(self, iprot):
14176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14178 
      return
14179 
    iprot.readStructBegin()
14180 
    while True:
14181 
      (fname, ftype, fid) = iprot.readFieldBegin()
14182 
      if ftype == TType.STOP:
14183 
        break
14184 
      else:
14185 
        iprot.skip(ftype)
14186 
      iprot.readFieldEnd()
14187 
    iprot.readStructEnd()
14188 
 
14189 
  def write(self, oprot):
14190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14192 
      return
2981 rajveer 14193 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14194 
    oprot.writeFieldStop()
14195 
    oprot.writeStructEnd()
14196 
 
3431 rajveer 14197 
  def validate(self):
14198 
    return
14199 
 
14200 
 
2642 varun.gupt 14201 
  def __repr__(self):
14202 
    L = ['%s=%r' % (key, value)
14203 
      for key, value in self.__dict__.iteritems()]
14204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14205 
 
14206 
  def __eq__(self, other):
14207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14208 
 
14209 
  def __ne__(self, other):
14210 
    return not (self == other)
14211 
 
3385 varun.gupt 14212 
class getCartsWithCouponCount_args:
14213 
  """
14214 
  Attributes:
14215 
   - couponCode
14216 
  """
2642 varun.gupt 14217 
 
3385 varun.gupt 14218 
  thrift_spec = (
14219 
    None, # 0
14220 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14221 
  )
14222 
 
14223 
  def __init__(self, couponCode=None,):
14224 
    self.couponCode = couponCode
14225 
 
14226 
  def read(self, iprot):
14227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14229 
      return
14230 
    iprot.readStructBegin()
14231 
    while True:
14232 
      (fname, ftype, fid) = iprot.readFieldBegin()
14233 
      if ftype == TType.STOP:
14234 
        break
14235 
      if fid == 1:
14236 
        if ftype == TType.STRING:
14237 
          self.couponCode = iprot.readString();
14238 
        else:
14239 
          iprot.skip(ftype)
14240 
      else:
14241 
        iprot.skip(ftype)
14242 
      iprot.readFieldEnd()
14243 
    iprot.readStructEnd()
14244 
 
14245 
  def write(self, oprot):
14246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14248 
      return
14249 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14250 
    if self.couponCode is not None:
3385 varun.gupt 14251 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14252 
      oprot.writeString(self.couponCode)
14253 
      oprot.writeFieldEnd()
14254 
    oprot.writeFieldStop()
14255 
    oprot.writeStructEnd()
14256 
 
3431 rajveer 14257 
  def validate(self):
14258 
    return
14259 
 
14260 
 
3385 varun.gupt 14261 
  def __repr__(self):
14262 
    L = ['%s=%r' % (key, value)
14263 
      for key, value in self.__dict__.iteritems()]
14264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14265 
 
14266 
  def __eq__(self, other):
14267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14268 
 
14269 
  def __ne__(self, other):
14270 
    return not (self == other)
14271 
 
14272 
class getCartsWithCouponCount_result:
14273 
  """
14274 
  Attributes:
14275 
   - success
14276 
  """
14277 
 
14278 
  thrift_spec = (
14279 
    (0, TType.I64, 'success', None, None, ), # 0
14280 
  )
14281 
 
14282 
  def __init__(self, success=None,):
14283 
    self.success = success
14284 
 
14285 
  def read(self, iprot):
14286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14288 
      return
14289 
    iprot.readStructBegin()
14290 
    while True:
14291 
      (fname, ftype, fid) = iprot.readFieldBegin()
14292 
      if ftype == TType.STOP:
14293 
        break
14294 
      if fid == 0:
14295 
        if ftype == TType.I64:
14296 
          self.success = iprot.readI64();
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      else:
14300 
        iprot.skip(ftype)
14301 
      iprot.readFieldEnd()
14302 
    iprot.readStructEnd()
14303 
 
14304 
  def write(self, oprot):
14305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14307 
      return
14308 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14309 
    if self.success is not None:
3385 varun.gupt 14310 
      oprot.writeFieldBegin('success', TType.I64, 0)
14311 
      oprot.writeI64(self.success)
14312 
      oprot.writeFieldEnd()
14313 
    oprot.writeFieldStop()
14314 
    oprot.writeStructEnd()
14315 
 
3431 rajveer 14316 
  def validate(self):
14317 
    return
14318 
 
14319 
 
3385 varun.gupt 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)
3499 mandeep.dh 14330 
 
14331 
class increaseTrustLevel_args:
14332 
  """
14333 
  Attributes:
14334 
   - userId
14335 
   - trustLevelDelta
14336 
  """
14337 
 
14338 
  thrift_spec = (
14339 
    None, # 0
14340 
    (1, TType.I64, 'userId', None, None, ), # 1
14341 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14342 
  )
14343 
 
14344 
  def __init__(self, userId=None, trustLevelDelta=None,):
14345 
    self.userId = userId
14346 
    self.trustLevelDelta = trustLevelDelta
14347 
 
14348 
  def read(self, iprot):
14349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14351 
      return
14352 
    iprot.readStructBegin()
14353 
    while True:
14354 
      (fname, ftype, fid) = iprot.readFieldBegin()
14355 
      if ftype == TType.STOP:
14356 
        break
14357 
      if fid == 1:
14358 
        if ftype == TType.I64:
14359 
          self.userId = iprot.readI64();
14360 
        else:
14361 
          iprot.skip(ftype)
14362 
      elif fid == 2:
14363 
        if ftype == TType.DOUBLE:
14364 
          self.trustLevelDelta = iprot.readDouble();
14365 
        else:
14366 
          iprot.skip(ftype)
14367 
      else:
14368 
        iprot.skip(ftype)
14369 
      iprot.readFieldEnd()
14370 
    iprot.readStructEnd()
14371 
 
14372 
  def write(self, oprot):
14373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14375 
      return
14376 
    oprot.writeStructBegin('increaseTrustLevel_args')
14377 
    if self.userId is not None:
14378 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14379 
      oprot.writeI64(self.userId)
14380 
      oprot.writeFieldEnd()
14381 
    if self.trustLevelDelta is not None:
14382 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14383 
      oprot.writeDouble(self.trustLevelDelta)
14384 
      oprot.writeFieldEnd()
14385 
    oprot.writeFieldStop()
14386 
    oprot.writeStructEnd()
14387 
 
14388 
  def validate(self):
14389 
    return
14390 
 
14391 
 
14392 
  def __repr__(self):
14393 
    L = ['%s=%r' % (key, value)
14394 
      for key, value in self.__dict__.iteritems()]
14395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14396 
 
14397 
  def __eq__(self, other):
14398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14399 
 
14400 
  def __ne__(self, other):
14401 
    return not (self == other)
4668 varun.gupt 14402 
 
5407 amar.kumar 14403 
class getTrustLevel_args:
14404 
  """
14405 
  Attributes:
14406 
   - userId
14407 
  """
14408 
 
14409 
  thrift_spec = (
14410 
    None, # 0
14411 
    (1, TType.I64, 'userId', None, None, ), # 1
14412 
  )
14413 
 
14414 
  def __init__(self, userId=None,):
14415 
    self.userId = userId
14416 
 
14417 
  def read(self, iprot):
14418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14420 
      return
14421 
    iprot.readStructBegin()
14422 
    while True:
14423 
      (fname, ftype, fid) = iprot.readFieldBegin()
14424 
      if ftype == TType.STOP:
14425 
        break
14426 
      if fid == 1:
14427 
        if ftype == TType.I64:
14428 
          self.userId = iprot.readI64();
14429 
        else:
14430 
          iprot.skip(ftype)
14431 
      else:
14432 
        iprot.skip(ftype)
14433 
      iprot.readFieldEnd()
14434 
    iprot.readStructEnd()
14435 
 
14436 
  def write(self, oprot):
14437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14439 
      return
14440 
    oprot.writeStructBegin('getTrustLevel_args')
14441 
    if self.userId is not None:
14442 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14443 
      oprot.writeI64(self.userId)
14444 
      oprot.writeFieldEnd()
14445 
    oprot.writeFieldStop()
14446 
    oprot.writeStructEnd()
14447 
 
14448 
  def validate(self):
14449 
    return
14450 
 
14451 
 
14452 
  def __repr__(self):
14453 
    L = ['%s=%r' % (key, value)
14454 
      for key, value in self.__dict__.iteritems()]
14455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14456 
 
14457 
  def __eq__(self, other):
14458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14459 
 
14460 
  def __ne__(self, other):
14461 
    return not (self == other)
14462 
 
14463 
class getTrustLevel_result:
14464 
  """
14465 
  Attributes:
14466 
   - success
14467 
  """
14468 
 
14469 
  thrift_spec = (
14470 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14471 
  )
14472 
 
14473 
  def __init__(self, success=None,):
14474 
    self.success = success
14475 
 
14476 
  def read(self, iprot):
14477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14479 
      return
14480 
    iprot.readStructBegin()
14481 
    while True:
14482 
      (fname, ftype, fid) = iprot.readFieldBegin()
14483 
      if ftype == TType.STOP:
14484 
        break
14485 
      if fid == 0:
14486 
        if ftype == TType.DOUBLE:
14487 
          self.success = iprot.readDouble();
14488 
        else:
14489 
          iprot.skip(ftype)
14490 
      else:
14491 
        iprot.skip(ftype)
14492 
      iprot.readFieldEnd()
14493 
    iprot.readStructEnd()
14494 
 
14495 
  def write(self, oprot):
14496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14498 
      return
14499 
    oprot.writeStructBegin('getTrustLevel_result')
14500 
    if self.success is not None:
14501 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14502 
      oprot.writeDouble(self.success)
14503 
      oprot.writeFieldEnd()
14504 
    oprot.writeFieldStop()
14505 
    oprot.writeStructEnd()
14506 
 
14507 
  def validate(self):
14508 
    return
14509 
 
14510 
 
14511 
  def __repr__(self):
14512 
    L = ['%s=%r' % (key, value)
14513 
      for key, value in self.__dict__.iteritems()]
14514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14515 
 
14516 
  def __eq__(self, other):
14517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14518 
 
14519 
  def __ne__(self, other):
14520 
    return not (self == other)
14521 
 
4668 varun.gupt 14522 
class showCODOption_args:
14523 
  """
14524 
  Attributes:
14525 
   - cartId
14526 
   - sourceId
14527 
   - pincode
14528 
  """
14529 
 
14530 
  thrift_spec = (
14531 
    None, # 0
14532 
    (1, TType.I64, 'cartId', None, None, ), # 1
14533 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14534 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14535 
  )
14536 
 
14537 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14538 
    self.cartId = cartId
14539 
    self.sourceId = sourceId
14540 
    self.pincode = pincode
14541 
 
14542 
  def read(self, iprot):
14543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14545 
      return
14546 
    iprot.readStructBegin()
14547 
    while True:
14548 
      (fname, ftype, fid) = iprot.readFieldBegin()
14549 
      if ftype == TType.STOP:
14550 
        break
14551 
      if fid == 1:
14552 
        if ftype == TType.I64:
14553 
          self.cartId = iprot.readI64();
14554 
        else:
14555 
          iprot.skip(ftype)
14556 
      elif fid == 2:
14557 
        if ftype == TType.I64:
14558 
          self.sourceId = iprot.readI64();
14559 
        else:
14560 
          iprot.skip(ftype)
14561 
      elif fid == 3:
14562 
        if ftype == TType.STRING:
14563 
          self.pincode = iprot.readString();
14564 
        else:
14565 
          iprot.skip(ftype)
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('showCODOption_args')
14576 
    if self.cartId is not None:
14577 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14578 
      oprot.writeI64(self.cartId)
14579 
      oprot.writeFieldEnd()
14580 
    if self.sourceId is not None:
14581 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14582 
      oprot.writeI64(self.sourceId)
14583 
      oprot.writeFieldEnd()
14584 
    if self.pincode is not None:
14585 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14586 
      oprot.writeString(self.pincode)
14587 
      oprot.writeFieldEnd()
14588 
    oprot.writeFieldStop()
14589 
    oprot.writeStructEnd()
14590 
 
14591 
  def validate(self):
14592 
    return
14593 
 
14594 
 
14595 
  def __repr__(self):
14596 
    L = ['%s=%r' % (key, value)
14597 
      for key, value in self.__dict__.iteritems()]
14598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14599 
 
14600 
  def __eq__(self, other):
14601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14602 
 
14603 
  def __ne__(self, other):
14604 
    return not (self == other)
14605 
 
14606 
class showCODOption_result:
14607 
  """
14608 
  Attributes:
14609 
   - success
14610 
  """
14611 
 
14612 
  thrift_spec = (
14613 
    (0, TType.BOOL, 'success', None, None, ), # 0
14614 
  )
14615 
 
14616 
  def __init__(self, success=None,):
14617 
    self.success = success
14618 
 
14619 
  def read(self, iprot):
14620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14622 
      return
14623 
    iprot.readStructBegin()
14624 
    while True:
14625 
      (fname, ftype, fid) = iprot.readFieldBegin()
14626 
      if ftype == TType.STOP:
14627 
        break
14628 
      if fid == 0:
14629 
        if ftype == TType.BOOL:
14630 
          self.success = iprot.readBool();
14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      else:
14634 
        iprot.skip(ftype)
14635 
      iprot.readFieldEnd()
14636 
    iprot.readStructEnd()
14637 
 
14638 
  def write(self, oprot):
14639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14641 
      return
14642 
    oprot.writeStructBegin('showCODOption_result')
14643 
    if self.success is not None:
14644 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14645 
      oprot.writeBool(self.success)
14646 
      oprot.writeFieldEnd()
14647 
    oprot.writeFieldStop()
14648 
    oprot.writeStructEnd()
14649 
 
14650 
  def validate(self):
14651 
    return
14652 
 
14653 
 
14654 
  def __repr__(self):
14655 
    L = ['%s=%r' % (key, value)
14656 
      for key, value in self.__dict__.iteritems()]
14657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14658 
 
14659 
  def __eq__(self, other):
14660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14661 
 
14662 
  def __ne__(self, other):
14663 
    return not (self == other)
5623 anupam.sin 14664 
 
14665 
class getUserEmails_args:
14666 
  """
14667 
  Attributes:
14668 
   - startDate
14669 
   - endDate
14670 
  """
14671 
 
14672 
  thrift_spec = (
14673 
    None, # 0
14674 
    (1, TType.I64, 'startDate', None, None, ), # 1
14675 
    (2, TType.I64, 'endDate', None, None, ), # 2
14676 
  )
14677 
 
14678 
  def __init__(self, startDate=None, endDate=None,):
14679 
    self.startDate = startDate
14680 
    self.endDate = endDate
14681 
 
14682 
  def read(self, iprot):
14683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14685 
      return
14686 
    iprot.readStructBegin()
14687 
    while True:
14688 
      (fname, ftype, fid) = iprot.readFieldBegin()
14689 
      if ftype == TType.STOP:
14690 
        break
14691 
      if fid == 1:
14692 
        if ftype == TType.I64:
14693 
          self.startDate = iprot.readI64();
14694 
        else:
14695 
          iprot.skip(ftype)
14696 
      elif fid == 2:
14697 
        if ftype == TType.I64:
14698 
          self.endDate = iprot.readI64();
14699 
        else:
14700 
          iprot.skip(ftype)
14701 
      else:
14702 
        iprot.skip(ftype)
14703 
      iprot.readFieldEnd()
14704 
    iprot.readStructEnd()
14705 
 
14706 
  def write(self, oprot):
14707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14709 
      return
14710 
    oprot.writeStructBegin('getUserEmails_args')
14711 
    if self.startDate is not None:
14712 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14713 
      oprot.writeI64(self.startDate)
14714 
      oprot.writeFieldEnd()
14715 
    if self.endDate is not None:
14716 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14717 
      oprot.writeI64(self.endDate)
14718 
      oprot.writeFieldEnd()
14719 
    oprot.writeFieldStop()
14720 
    oprot.writeStructEnd()
14721 
 
14722 
  def validate(self):
14723 
    return
14724 
 
14725 
 
14726 
  def __repr__(self):
14727 
    L = ['%s=%r' % (key, value)
14728 
      for key, value in self.__dict__.iteritems()]
14729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14730 
 
14731 
  def __eq__(self, other):
14732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14733 
 
14734 
  def __ne__(self, other):
14735 
    return not (self == other)
14736 
 
14737 
class getUserEmails_result:
14738 
  """
14739 
  Attributes:
14740 
   - success
14741 
  """
14742 
 
14743 
  thrift_spec = (
14744 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14745 
  )
14746 
 
14747 
  def __init__(self, success=None,):
14748 
    self.success = success
14749 
 
14750 
  def read(self, iprot):
14751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14753 
      return
14754 
    iprot.readStructBegin()
14755 
    while True:
14756 
      (fname, ftype, fid) = iprot.readFieldBegin()
14757 
      if ftype == TType.STOP:
14758 
        break
14759 
      if fid == 0:
14760 
        if ftype == TType.LIST:
14761 
          self.success = []
11980 amit.gupta 14762 
          (_etype214, _size211) = iprot.readListBegin()
14763 
          for _i215 in xrange(_size211):
14764 
            _elem216 = iprot.readString();
14765 
            self.success.append(_elem216)
5623 anupam.sin 14766 
          iprot.readListEnd()
14767 
        else:
14768 
          iprot.skip(ftype)
14769 
      else:
14770 
        iprot.skip(ftype)
14771 
      iprot.readFieldEnd()
14772 
    iprot.readStructEnd()
14773 
 
14774 
  def write(self, oprot):
14775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14777 
      return
14778 
    oprot.writeStructBegin('getUserEmails_result')
14779 
    if self.success is not None:
14780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14781 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14782 
      for iter217 in self.success:
14783 
        oprot.writeString(iter217)
5623 anupam.sin 14784 
      oprot.writeListEnd()
14785 
      oprot.writeFieldEnd()
14786 
    oprot.writeFieldStop()
14787 
    oprot.writeStructEnd()
14788 
 
14789 
  def validate(self):
14790 
    return
14791 
 
14792 
 
14793 
  def __repr__(self):
14794 
    L = ['%s=%r' % (key, value)
14795 
      for key, value in self.__dict__.iteritems()]
14796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14797 
 
14798 
  def __eq__(self, other):
14799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14800 
 
14801 
  def __ne__(self, other):
14802 
    return not (self == other)
6821 amar.kumar 14803 
 
6903 anupam.sin 14804 
class insureItem_args:
14805 
  """
14806 
  Attributes:
14807 
   - itemId
14808 
   - cartId
14809 
   - toInsure
9299 kshitij.so 14810 
   - insurerType
6903 anupam.sin 14811 
  """
14812 
 
14813 
  thrift_spec = (
14814 
    None, # 0
14815 
    (1, TType.I64, 'itemId', None, None, ), # 1
14816 
    (2, TType.I64, 'cartId', None, None, ), # 2
14817 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14818 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14819 
  )
14820 
 
9299 kshitij.so 14821 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14822 
    self.itemId = itemId
14823 
    self.cartId = cartId
14824 
    self.toInsure = toInsure
9299 kshitij.so 14825 
    self.insurerType = insurerType
6903 anupam.sin 14826 
 
14827 
  def read(self, iprot):
14828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14830 
      return
14831 
    iprot.readStructBegin()
14832 
    while True:
14833 
      (fname, ftype, fid) = iprot.readFieldBegin()
14834 
      if ftype == TType.STOP:
14835 
        break
14836 
      if fid == 1:
14837 
        if ftype == TType.I64:
14838 
          self.itemId = iprot.readI64();
14839 
        else:
14840 
          iprot.skip(ftype)
14841 
      elif fid == 2:
14842 
        if ftype == TType.I64:
14843 
          self.cartId = iprot.readI64();
14844 
        else:
14845 
          iprot.skip(ftype)
14846 
      elif fid == 3:
14847 
        if ftype == TType.BOOL:
14848 
          self.toInsure = iprot.readBool();
14849 
        else:
14850 
          iprot.skip(ftype)
9299 kshitij.so 14851 
      elif fid == 4:
14852 
        if ftype == TType.I32:
14853 
          self.insurerType = iprot.readI32();
14854 
        else:
14855 
          iprot.skip(ftype)
6903 anupam.sin 14856 
      else:
14857 
        iprot.skip(ftype)
14858 
      iprot.readFieldEnd()
14859 
    iprot.readStructEnd()
14860 
 
14861 
  def write(self, oprot):
14862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14864 
      return
14865 
    oprot.writeStructBegin('insureItem_args')
14866 
    if self.itemId is not None:
14867 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14868 
      oprot.writeI64(self.itemId)
14869 
      oprot.writeFieldEnd()
14870 
    if self.cartId is not None:
14871 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14872 
      oprot.writeI64(self.cartId)
14873 
      oprot.writeFieldEnd()
14874 
    if self.toInsure is not None:
14875 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14876 
      oprot.writeBool(self.toInsure)
14877 
      oprot.writeFieldEnd()
9299 kshitij.so 14878 
    if self.insurerType is not None:
14879 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14880 
      oprot.writeI32(self.insurerType)
14881 
      oprot.writeFieldEnd()
6903 anupam.sin 14882 
    oprot.writeFieldStop()
14883 
    oprot.writeStructEnd()
14884 
 
14885 
  def validate(self):
14886 
    return
14887 
 
14888 
 
14889 
  def __repr__(self):
14890 
    L = ['%s=%r' % (key, value)
14891 
      for key, value in self.__dict__.iteritems()]
14892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14893 
 
14894 
  def __eq__(self, other):
14895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14896 
 
14897 
  def __ne__(self, other):
14898 
    return not (self == other)
14899 
 
14900 
class insureItem_result:
14901 
  """
14902 
  Attributes:
14903 
   - success
14904 
  """
14905 
 
14906 
  thrift_spec = (
14907 
    (0, TType.BOOL, 'success', None, None, ), # 0
14908 
  )
14909 
 
14910 
  def __init__(self, success=None,):
14911 
    self.success = success
14912 
 
14913 
  def read(self, iprot):
14914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14916 
      return
14917 
    iprot.readStructBegin()
14918 
    while True:
14919 
      (fname, ftype, fid) = iprot.readFieldBegin()
14920 
      if ftype == TType.STOP:
14921 
        break
14922 
      if fid == 0:
14923 
        if ftype == TType.BOOL:
14924 
          self.success = iprot.readBool();
14925 
        else:
14926 
          iprot.skip(ftype)
14927 
      else:
14928 
        iprot.skip(ftype)
14929 
      iprot.readFieldEnd()
14930 
    iprot.readStructEnd()
14931 
 
14932 
  def write(self, oprot):
14933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14935 
      return
14936 
    oprot.writeStructBegin('insureItem_result')
14937 
    if self.success is not None:
14938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14939 
      oprot.writeBool(self.success)
14940 
      oprot.writeFieldEnd()
14941 
    oprot.writeFieldStop()
14942 
    oprot.writeStructEnd()
14943 
 
14944 
  def validate(self):
14945 
    return
14946 
 
14947 
 
14948 
  def __repr__(self):
14949 
    L = ['%s=%r' % (key, value)
14950 
      for key, value in self.__dict__.iteritems()]
14951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14952 
 
14953 
  def __eq__(self, other):
14954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14955 
 
14956 
  def __ne__(self, other):
14957 
    return not (self == other)
14958 
 
14959 
class cancelInsurance_args:
14960 
  """
14961 
  Attributes:
14962 
   - cartId
14963 
  """
14964 
 
14965 
  thrift_spec = (
14966 
    None, # 0
14967 
    (1, TType.I64, 'cartId', None, None, ), # 1
14968 
  )
14969 
 
14970 
  def __init__(self, cartId=None,):
14971 
    self.cartId = cartId
14972 
 
14973 
  def read(self, iprot):
14974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14976 
      return
14977 
    iprot.readStructBegin()
14978 
    while True:
14979 
      (fname, ftype, fid) = iprot.readFieldBegin()
14980 
      if ftype == TType.STOP:
14981 
        break
14982 
      if fid == 1:
14983 
        if ftype == TType.I64:
14984 
          self.cartId = iprot.readI64();
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      else:
14988 
        iprot.skip(ftype)
14989 
      iprot.readFieldEnd()
14990 
    iprot.readStructEnd()
14991 
 
14992 
  def write(self, oprot):
14993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14995 
      return
14996 
    oprot.writeStructBegin('cancelInsurance_args')
14997 
    if self.cartId is not None:
14998 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14999 
      oprot.writeI64(self.cartId)
15000 
      oprot.writeFieldEnd()
15001 
    oprot.writeFieldStop()
15002 
    oprot.writeStructEnd()
15003 
 
15004 
  def validate(self):
15005 
    return
15006 
 
15007 
 
15008 
  def __repr__(self):
15009 
    L = ['%s=%r' % (key, value)
15010 
      for key, value in self.__dict__.iteritems()]
15011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15012 
 
15013 
  def __eq__(self, other):
15014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15015 
 
15016 
  def __ne__(self, other):
15017 
    return not (self == other)
15018 
 
15019 
class cancelInsurance_result:
15020 
  """
15021 
  Attributes:
15022 
   - success
15023 
  """
15024 
 
15025 
  thrift_spec = (
15026 
    (0, TType.BOOL, 'success', None, None, ), # 0
15027 
  )
15028 
 
15029 
  def __init__(self, success=None,):
15030 
    self.success = success
15031 
 
15032 
  def read(self, iprot):
15033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15035 
      return
15036 
    iprot.readStructBegin()
15037 
    while True:
15038 
      (fname, ftype, fid) = iprot.readFieldBegin()
15039 
      if ftype == TType.STOP:
15040 
        break
15041 
      if fid == 0:
15042 
        if ftype == TType.BOOL:
15043 
          self.success = iprot.readBool();
15044 
        else:
15045 
          iprot.skip(ftype)
15046 
      else:
15047 
        iprot.skip(ftype)
15048 
      iprot.readFieldEnd()
15049 
    iprot.readStructEnd()
15050 
 
15051 
  def write(self, oprot):
15052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15054 
      return
15055 
    oprot.writeStructBegin('cancelInsurance_result')
15056 
    if self.success is not None:
15057 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15058 
      oprot.writeBool(self.success)
15059 
      oprot.writeFieldEnd()
15060 
    oprot.writeFieldStop()
15061 
    oprot.writeStructEnd()
15062 
 
15063 
  def validate(self):
15064 
    return
15065 
 
15066 
 
15067 
  def __repr__(self):
15068 
    L = ['%s=%r' % (key, value)
15069 
      for key, value in self.__dict__.iteritems()]
15070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15071 
 
15072 
  def __eq__(self, other):
15073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15074 
 
15075 
  def __ne__(self, other):
15076 
    return not (self == other)
15077 
 
15078 
class storeInsuranceSpecificDetails_args:
15079 
  """
15080 
  Attributes:
15081 
   - addressId
15082 
   - dob
15083 
   - guardianName
15084 
  """
15085 
 
15086 
  thrift_spec = (
15087 
    None, # 0
15088 
    (1, TType.I64, 'addressId', None, None, ), # 1
15089 
    (2, TType.STRING, 'dob', None, None, ), # 2
15090 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15091 
  )
15092 
 
15093 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15094 
    self.addressId = addressId
15095 
    self.dob = dob
15096 
    self.guardianName = guardianName
15097 
 
15098 
  def read(self, iprot):
15099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15101 
      return
15102 
    iprot.readStructBegin()
15103 
    while True:
15104 
      (fname, ftype, fid) = iprot.readFieldBegin()
15105 
      if ftype == TType.STOP:
15106 
        break
15107 
      if fid == 1:
15108 
        if ftype == TType.I64:
15109 
          self.addressId = iprot.readI64();
15110 
        else:
15111 
          iprot.skip(ftype)
15112 
      elif fid == 2:
15113 
        if ftype == TType.STRING:
15114 
          self.dob = iprot.readString();
15115 
        else:
15116 
          iprot.skip(ftype)
15117 
      elif fid == 3:
15118 
        if ftype == TType.STRING:
15119 
          self.guardianName = iprot.readString();
15120 
        else:
15121 
          iprot.skip(ftype)
15122 
      else:
15123 
        iprot.skip(ftype)
15124 
      iprot.readFieldEnd()
15125 
    iprot.readStructEnd()
15126 
 
15127 
  def write(self, oprot):
15128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15130 
      return
15131 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15132 
    if self.addressId is not None:
15133 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15134 
      oprot.writeI64(self.addressId)
15135 
      oprot.writeFieldEnd()
15136 
    if self.dob is not None:
15137 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15138 
      oprot.writeString(self.dob)
15139 
      oprot.writeFieldEnd()
15140 
    if self.guardianName is not None:
15141 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15142 
      oprot.writeString(self.guardianName)
15143 
      oprot.writeFieldEnd()
15144 
    oprot.writeFieldStop()
15145 
    oprot.writeStructEnd()
15146 
 
15147 
  def validate(self):
15148 
    return
15149 
 
15150 
 
15151 
  def __repr__(self):
15152 
    L = ['%s=%r' % (key, value)
15153 
      for key, value in self.__dict__.iteritems()]
15154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15155 
 
15156 
  def __eq__(self, other):
15157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15158 
 
15159 
  def __ne__(self, other):
15160 
    return not (self == other)
15161 
 
15162 
class storeInsuranceSpecificDetails_result:
15163 
  """
15164 
  Attributes:
15165 
   - success
15166 
  """
15167 
 
15168 
  thrift_spec = (
15169 
    (0, TType.BOOL, 'success', None, None, ), # 0
15170 
  )
15171 
 
15172 
  def __init__(self, success=None,):
15173 
    self.success = success
15174 
 
15175 
  def read(self, iprot):
15176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15178 
      return
15179 
    iprot.readStructBegin()
15180 
    while True:
15181 
      (fname, ftype, fid) = iprot.readFieldBegin()
15182 
      if ftype == TType.STOP:
15183 
        break
15184 
      if fid == 0:
15185 
        if ftype == TType.BOOL:
15186 
          self.success = iprot.readBool();
15187 
        else:
15188 
          iprot.skip(ftype)
15189 
      else:
15190 
        iprot.skip(ftype)
15191 
      iprot.readFieldEnd()
15192 
    iprot.readStructEnd()
15193 
 
15194 
  def write(self, oprot):
15195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15197 
      return
15198 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15199 
    if self.success is not None:
15200 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15201 
      oprot.writeBool(self.success)
15202 
      oprot.writeFieldEnd()
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
15221 
class isInsuranceDetailPresent_args:
15222 
  """
15223 
  Attributes:
15224 
   - addressId
15225 
  """
15226 
 
15227 
  thrift_spec = (
15228 
    None, # 0
15229 
    (1, TType.I64, 'addressId', None, None, ), # 1
15230 
  )
15231 
 
15232 
  def __init__(self, addressId=None,):
15233 
    self.addressId = addressId
15234 
 
15235 
  def read(self, iprot):
15236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15238 
      return
15239 
    iprot.readStructBegin()
15240 
    while True:
15241 
      (fname, ftype, fid) = iprot.readFieldBegin()
15242 
      if ftype == TType.STOP:
15243 
        break
15244 
      if fid == 1:
15245 
        if ftype == TType.I64:
15246 
          self.addressId = iprot.readI64();
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15259 
    if self.addressId is not None:
15260 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15261 
      oprot.writeI64(self.addressId)
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class isInsuranceDetailPresent_result:
15282 
  """
15283 
  Attributes:
15284 
   - success
15285 
  """
15286 
 
15287 
  thrift_spec = (
15288 
    (0, TType.BOOL, 'success', None, None, ), # 0
15289 
  )
15290 
 
15291 
  def __init__(self, success=None,):
15292 
    self.success = success
15293 
 
15294 
  def read(self, iprot):
15295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15297 
      return
15298 
    iprot.readStructBegin()
15299 
    while True:
15300 
      (fname, ftype, fid) = iprot.readFieldBegin()
15301 
      if ftype == TType.STOP:
15302 
        break
15303 
      if fid == 0:
15304 
        if ftype == TType.BOOL:
15305 
          self.success = iprot.readBool();
15306 
        else:
15307 
          iprot.skip(ftype)
15308 
      else:
15309 
        iprot.skip(ftype)
15310 
      iprot.readFieldEnd()
15311 
    iprot.readStructEnd()
15312 
 
15313 
  def write(self, oprot):
15314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15316 
      return
15317 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15318 
    if self.success is not None:
15319 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15320 
      oprot.writeBool(self.success)
15321 
      oprot.writeFieldEnd()
15322 
    oprot.writeFieldStop()
15323 
    oprot.writeStructEnd()
15324 
 
15325 
  def validate(self):
15326 
    return
15327 
 
15328 
 
15329 
  def __repr__(self):
15330 
    L = ['%s=%r' % (key, value)
15331 
      for key, value in self.__dict__.iteritems()]
15332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15333 
 
15334 
  def __eq__(self, other):
15335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15336 
 
15337 
  def __ne__(self, other):
15338 
    return not (self == other)
15339 
 
9791 rajveer 15340 
class getProductsAddedToCart_args:
6821 amar.kumar 15341 
  """
15342 
  Attributes:
15343 
   - startDate
15344 
   - endDate
15345 
  """
15346 
 
15347 
  thrift_spec = (
15348 
    None, # 0
9791 rajveer 15349 
    (1, TType.I64, 'startDate', None, None, ), # 1
15350 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15351 
  )
15352 
 
9791 rajveer 15353 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15354 
    self.startDate = startDate
15355 
    self.endDate = endDate
15356 
 
15357 
  def read(self, iprot):
15358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15360 
      return
15361 
    iprot.readStructBegin()
15362 
    while True:
15363 
      (fname, ftype, fid) = iprot.readFieldBegin()
15364 
      if ftype == TType.STOP:
15365 
        break
15366 
      if fid == 1:
15367 
        if ftype == TType.I64:
9791 rajveer 15368 
          self.startDate = iprot.readI64();
6821 amar.kumar 15369 
        else:
15370 
          iprot.skip(ftype)
15371 
      elif fid == 2:
15372 
        if ftype == TType.I64:
15373 
          self.endDate = iprot.readI64();
15374 
        else:
15375 
          iprot.skip(ftype)
15376 
      else:
15377 
        iprot.skip(ftype)
15378 
      iprot.readFieldEnd()
15379 
    iprot.readStructEnd()
15380 
 
15381 
  def write(self, oprot):
15382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15384 
      return
9791 rajveer 15385 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15386 
    if self.startDate is not None:
9791 rajveer 15387 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15388 
      oprot.writeI64(self.startDate)
15389 
      oprot.writeFieldEnd()
15390 
    if self.endDate is not None:
9791 rajveer 15391 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15392 
      oprot.writeI64(self.endDate)
15393 
      oprot.writeFieldEnd()
15394 
    oprot.writeFieldStop()
15395 
    oprot.writeStructEnd()
15396 
 
15397 
  def validate(self):
15398 
    return
15399 
 
15400 
 
15401 
  def __repr__(self):
15402 
    L = ['%s=%r' % (key, value)
15403 
      for key, value in self.__dict__.iteritems()]
15404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15405 
 
15406 
  def __eq__(self, other):
15407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15408 
 
15409 
  def __ne__(self, other):
15410 
    return not (self == other)
15411 
 
9791 rajveer 15412 
class getProductsAddedToCart_result:
6821 amar.kumar 15413 
  """
15414 
  Attributes:
15415 
   - success
15416 
  """
15417 
 
15418 
  thrift_spec = (
9791 rajveer 15419 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15420 
  )
15421 
 
15422 
  def __init__(self, success=None,):
15423 
    self.success = success
15424 
 
15425 
  def read(self, iprot):
15426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15428 
      return
15429 
    iprot.readStructBegin()
15430 
    while True:
15431 
      (fname, ftype, fid) = iprot.readFieldBegin()
15432 
      if ftype == TType.STOP:
15433 
        break
15434 
      if fid == 0:
9791 rajveer 15435 
        if ftype == TType.LIST:
15436 
          self.success = []
11980 amit.gupta 15437 
          (_etype221, _size218) = iprot.readListBegin()
15438 
          for _i222 in xrange(_size218):
15439 
            _elem223 = iprot.readI64();
15440 
            self.success.append(_elem223)
9791 rajveer 15441 
          iprot.readListEnd()
6821 amar.kumar 15442 
        else:
15443 
          iprot.skip(ftype)
15444 
      else:
15445 
        iprot.skip(ftype)
15446 
      iprot.readFieldEnd()
15447 
    iprot.readStructEnd()
15448 
 
15449 
  def write(self, oprot):
15450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15452 
      return
9791 rajveer 15453 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15454 
    if self.success is not None:
9791 rajveer 15455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15456 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15457 
      for iter224 in self.success:
15458 
        oprot.writeI64(iter224)
9791 rajveer 15459 
      oprot.writeListEnd()
6821 amar.kumar 15460 
      oprot.writeFieldEnd()
15461 
    oprot.writeFieldStop()
15462 
    oprot.writeStructEnd()
15463 
 
15464 
  def validate(self):
15465 
    return
15466 
 
15467 
 
15468 
  def __repr__(self):
15469 
    L = ['%s=%r' % (key, value)
15470 
      for key, value in self.__dict__.iteritems()]
15471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15472 
 
15473 
  def __eq__(self, other):
15474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15475 
 
15476 
  def __ne__(self, other):
15477 
    return not (self == other)
11592 amit.gupta 15478 
 
15479 
class validateCartPlus_args:
15480 
  """
15481 
  Attributes:
15482 
   - cartId
15483 
   - sourceId
11980 amit.gupta 15484 
   - dealerCoupon
11592 amit.gupta 15485 
  """
15486 
 
15487 
  thrift_spec = (
15488 
    None, # 0
15489 
    (1, TType.I64, 'cartId', None, None, ), # 1
15490 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15491 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15492 
  )
15493 
 
11980 amit.gupta 15494 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15495 
    self.cartId = cartId
15496 
    self.sourceId = sourceId
11980 amit.gupta 15497 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15498 
 
15499 
  def read(self, iprot):
15500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15502 
      return
15503 
    iprot.readStructBegin()
15504 
    while True:
15505 
      (fname, ftype, fid) = iprot.readFieldBegin()
15506 
      if ftype == TType.STOP:
15507 
        break
15508 
      if fid == 1:
15509 
        if ftype == TType.I64:
15510 
          self.cartId = iprot.readI64();
15511 
        else:
15512 
          iprot.skip(ftype)
15513 
      elif fid == 2:
15514 
        if ftype == TType.I64:
15515 
          self.sourceId = iprot.readI64();
15516 
        else:
15517 
          iprot.skip(ftype)
11980 amit.gupta 15518 
      elif fid == 3:
15519 
        if ftype == TType.STRING:
15520 
          self.dealerCoupon = iprot.readString();
15521 
        else:
15522 
          iprot.skip(ftype)
11592 amit.gupta 15523 
      else:
15524 
        iprot.skip(ftype)
15525 
      iprot.readFieldEnd()
15526 
    iprot.readStructEnd()
15527 
 
15528 
  def write(self, oprot):
15529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15531 
      return
15532 
    oprot.writeStructBegin('validateCartPlus_args')
15533 
    if self.cartId is not None:
15534 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15535 
      oprot.writeI64(self.cartId)
15536 
      oprot.writeFieldEnd()
15537 
    if self.sourceId is not None:
15538 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15539 
      oprot.writeI64(self.sourceId)
15540 
      oprot.writeFieldEnd()
11980 amit.gupta 15541 
    if self.dealerCoupon is not None:
15542 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15543 
      oprot.writeString(self.dealerCoupon)
15544 
      oprot.writeFieldEnd()
11592 amit.gupta 15545 
    oprot.writeFieldStop()
15546 
    oprot.writeStructEnd()
15547 
 
15548 
  def validate(self):
15549 
    return
15550 
 
15551 
 
15552 
  def __repr__(self):
15553 
    L = ['%s=%r' % (key, value)
15554 
      for key, value in self.__dict__.iteritems()]
15555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15556 
 
15557 
  def __eq__(self, other):
15558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15559 
 
15560 
  def __ne__(self, other):
15561 
    return not (self == other)
15562 
 
15563 
class validateCartPlus_result:
15564 
  """
15565 
  Attributes:
15566 
   - success
15567 
   - scex
15568 
  """
15569 
 
15570 
  thrift_spec = (
15571 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15572 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15573 
  )
15574 
 
15575 
  def __init__(self, success=None, scex=None,):
15576 
    self.success = success
15577 
    self.scex = scex
15578 
 
15579 
  def read(self, iprot):
15580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15582 
      return
15583 
    iprot.readStructBegin()
15584 
    while True:
15585 
      (fname, ftype, fid) = iprot.readFieldBegin()
15586 
      if ftype == TType.STOP:
15587 
        break
15588 
      if fid == 0:
15589 
        if ftype == TType.STRUCT:
15590 
          self.success = CartPlus()
15591 
          self.success.read(iprot)
15592 
        else:
15593 
          iprot.skip(ftype)
15594 
      elif fid == 1:
15595 
        if ftype == TType.STRUCT:
15596 
          self.scex = ShoppingCartException()
15597 
          self.scex.read(iprot)
15598 
        else:
15599 
          iprot.skip(ftype)
15600 
      else:
15601 
        iprot.skip(ftype)
15602 
      iprot.readFieldEnd()
15603 
    iprot.readStructEnd()
15604 
 
15605 
  def write(self, oprot):
15606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15608 
      return
15609 
    oprot.writeStructBegin('validateCartPlus_result')
15610 
    if self.success is not None:
15611 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15612 
      self.success.write(oprot)
15613 
      oprot.writeFieldEnd()
15614 
    if self.scex is not None:
15615 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15616 
      self.scex.write(oprot)
15617 
      oprot.writeFieldEnd()
15618 
    oprot.writeFieldStop()
15619 
    oprot.writeStructEnd()
15620 
 
15621 
  def validate(self):
15622 
    return
15623 
 
15624 
 
15625 
  def __repr__(self):
15626 
    L = ['%s=%r' % (key, value)
15627 
      for key, value in self.__dict__.iteritems()]
15628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15629 
 
15630 
  def __eq__(self, other):
15631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15632 
 
15633 
  def __ne__(self, other):
15634 
    return not (self == other)
11679 vikram.rag 15635 
 
15636 
class isPrivateDealUser_args:
15637 
  """
15638 
  Attributes:
15639 
   - userId
15640 
  """
15641 
 
15642 
  thrift_spec = (
15643 
    None, # 0
15644 
    (1, TType.I64, 'userId', None, None, ), # 1
15645 
  )
15646 
 
15647 
  def __init__(self, userId=None,):
15648 
    self.userId = userId
15649 
 
15650 
  def read(self, iprot):
15651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15653 
      return
15654 
    iprot.readStructBegin()
15655 
    while True:
15656 
      (fname, ftype, fid) = iprot.readFieldBegin()
15657 
      if ftype == TType.STOP:
15658 
        break
15659 
      if fid == 1:
15660 
        if ftype == TType.I64:
15661 
          self.userId = iprot.readI64();
15662 
        else:
15663 
          iprot.skip(ftype)
15664 
      else:
15665 
        iprot.skip(ftype)
15666 
      iprot.readFieldEnd()
15667 
    iprot.readStructEnd()
15668 
 
15669 
  def write(self, oprot):
15670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15672 
      return
15673 
    oprot.writeStructBegin('isPrivateDealUser_args')
15674 
    if self.userId is not None:
15675 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15676 
      oprot.writeI64(self.userId)
15677 
      oprot.writeFieldEnd()
15678 
    oprot.writeFieldStop()
15679 
    oprot.writeStructEnd()
15680 
 
15681 
  def validate(self):
15682 
    return
15683 
 
15684 
 
15685 
  def __repr__(self):
15686 
    L = ['%s=%r' % (key, value)
15687 
      for key, value in self.__dict__.iteritems()]
15688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15689 
 
15690 
  def __eq__(self, other):
15691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15692 
 
15693 
  def __ne__(self, other):
15694 
    return not (self == other)
15695 
 
15696 
class isPrivateDealUser_result:
15697 
  """
15698 
  Attributes:
15699 
   - success
15700 
  """
15701 
 
15702 
  thrift_spec = (
15703 
    (0, TType.BOOL, 'success', None, None, ), # 0
15704 
  )
15705 
 
15706 
  def __init__(self, success=None,):
15707 
    self.success = success
15708 
 
15709 
  def read(self, iprot):
15710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15712 
      return
15713 
    iprot.readStructBegin()
15714 
    while True:
15715 
      (fname, ftype, fid) = iprot.readFieldBegin()
15716 
      if ftype == TType.STOP:
15717 
        break
15718 
      if fid == 0:
15719 
        if ftype == TType.BOOL:
15720 
          self.success = iprot.readBool();
15721 
        else:
15722 
          iprot.skip(ftype)
15723 
      else:
15724 
        iprot.skip(ftype)
15725 
      iprot.readFieldEnd()
15726 
    iprot.readStructEnd()
15727 
 
15728 
  def write(self, oprot):
15729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15731 
      return
15732 
    oprot.writeStructBegin('isPrivateDealUser_result')
15733 
    if self.success is not None:
15734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15735 
      oprot.writeBool(self.success)
15736 
      oprot.writeFieldEnd()
15737 
    oprot.writeFieldStop()
15738 
    oprot.writeStructEnd()
15739 
 
15740 
  def validate(self):
15741 
    return
15742 
 
15743 
 
15744 
  def __repr__(self):
15745 
    L = ['%s=%r' % (key, value)
15746 
      for key, value in self.__dict__.iteritems()]
15747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15748 
 
15749 
  def __eq__(self, other):
15750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15751 
 
15752 
  def __ne__(self, other):
15753 
    return not (self == other)
11890 kshitij.so 15754 
 
15755 
class addPrivateDealUser_args:
15756 
  """
15757 
  Attributes:
15758 
   - userId
15759 
  """
15760 
 
15761 
  thrift_spec = (
15762 
    None, # 0
15763 
    (1, TType.I64, 'userId', None, None, ), # 1
15764 
  )
15765 
 
15766 
  def __init__(self, userId=None,):
15767 
    self.userId = userId
15768 
 
15769 
  def read(self, iprot):
15770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15772 
      return
15773 
    iprot.readStructBegin()
15774 
    while True:
15775 
      (fname, ftype, fid) = iprot.readFieldBegin()
15776 
      if ftype == TType.STOP:
15777 
        break
15778 
      if fid == 1:
15779 
        if ftype == TType.I64:
15780 
          self.userId = iprot.readI64();
15781 
        else:
15782 
          iprot.skip(ftype)
15783 
      else:
15784 
        iprot.skip(ftype)
15785 
      iprot.readFieldEnd()
15786 
    iprot.readStructEnd()
15787 
 
15788 
  def write(self, oprot):
15789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15791 
      return
15792 
    oprot.writeStructBegin('addPrivateDealUser_args')
15793 
    if self.userId is not None:
15794 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15795 
      oprot.writeI64(self.userId)
15796 
      oprot.writeFieldEnd()
15797 
    oprot.writeFieldStop()
15798 
    oprot.writeStructEnd()
15799 
 
15800 
  def validate(self):
15801 
    return
15802 
 
15803 
 
15804 
  def __repr__(self):
15805 
    L = ['%s=%r' % (key, value)
15806 
      for key, value in self.__dict__.iteritems()]
15807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15808 
 
15809 
  def __eq__(self, other):
15810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15811 
 
15812 
  def __ne__(self, other):
15813 
    return not (self == other)
15814 
 
15815 
class addPrivateDealUser_result:
15816 
  """
15817 
  Attributes:
15818 
   - success
15819 
  """
15820 
 
15821 
  thrift_spec = (
15822 
    (0, TType.BOOL, 'success', None, None, ), # 0
15823 
  )
15824 
 
15825 
  def __init__(self, success=None,):
15826 
    self.success = success
15827 
 
15828 
  def read(self, iprot):
15829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15831 
      return
15832 
    iprot.readStructBegin()
15833 
    while True:
15834 
      (fname, ftype, fid) = iprot.readFieldBegin()
15835 
      if ftype == TType.STOP:
15836 
        break
15837 
      if fid == 0:
15838 
        if ftype == TType.BOOL:
15839 
          self.success = iprot.readBool();
15840 
        else:
15841 
          iprot.skip(ftype)
15842 
      else:
15843 
        iprot.skip(ftype)
15844 
      iprot.readFieldEnd()
15845 
    iprot.readStructEnd()
15846 
 
15847 
  def write(self, oprot):
15848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15850 
      return
15851 
    oprot.writeStructBegin('addPrivateDealUser_result')
15852 
    if self.success is not None:
15853 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15854 
      oprot.writeBool(self.success)
15855 
      oprot.writeFieldEnd()
15856 
    oprot.writeFieldStop()
15857 
    oprot.writeStructEnd()
15858 
 
15859 
  def validate(self):
15860 
    return
15861 
 
15862 
 
15863 
  def __repr__(self):
15864 
    L = ['%s=%r' % (key, value)
15865 
      for key, value in self.__dict__.iteritems()]
15866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15867 
 
15868 
  def __eq__(self, other):
15869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15870 
 
15871 
  def __ne__(self, other):
15872 
    return not (self == other)
15873 
 
15874 
class changePrivateDealUserStatus_args:
15875 
  """
15876 
  Attributes:
15877 
   - userId
15878 
   - isActive
15879 
  """
15880 
 
15881 
  thrift_spec = (
15882 
    None, # 0
15883 
    (1, TType.I64, 'userId', None, None, ), # 1
15884 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15885 
  )
15886 
 
15887 
  def __init__(self, userId=None, isActive=None,):
15888 
    self.userId = userId
15889 
    self.isActive = isActive
15890 
 
15891 
  def read(self, iprot):
15892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15894 
      return
15895 
    iprot.readStructBegin()
15896 
    while True:
15897 
      (fname, ftype, fid) = iprot.readFieldBegin()
15898 
      if ftype == TType.STOP:
15899 
        break
15900 
      if fid == 1:
15901 
        if ftype == TType.I64:
15902 
          self.userId = iprot.readI64();
15903 
        else:
15904 
          iprot.skip(ftype)
15905 
      elif fid == 2:
15906 
        if ftype == TType.BOOL:
15907 
          self.isActive = iprot.readBool();
15908 
        else:
15909 
          iprot.skip(ftype)
15910 
      else:
15911 
        iprot.skip(ftype)
15912 
      iprot.readFieldEnd()
15913 
    iprot.readStructEnd()
15914 
 
15915 
  def write(self, oprot):
15916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15918 
      return
15919 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15920 
    if self.userId is not None:
15921 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15922 
      oprot.writeI64(self.userId)
15923 
      oprot.writeFieldEnd()
15924 
    if self.isActive is not None:
15925 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15926 
      oprot.writeBool(self.isActive)
15927 
      oprot.writeFieldEnd()
15928 
    oprot.writeFieldStop()
15929 
    oprot.writeStructEnd()
15930 
 
15931 
  def validate(self):
15932 
    return
15933 
 
15934 
 
15935 
  def __repr__(self):
15936 
    L = ['%s=%r' % (key, value)
15937 
      for key, value in self.__dict__.iteritems()]
15938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15939 
 
15940 
  def __eq__(self, other):
15941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15942 
 
15943 
  def __ne__(self, other):
15944 
    return not (self == other)
15945 
 
15946 
class changePrivateDealUserStatus_result:
15947 
  """
15948 
  Attributes:
15949 
   - success
15950 
  """
15951 
 
15952 
  thrift_spec = (
15953 
    (0, TType.BOOL, 'success', None, None, ), # 0
15954 
  )
15955 
 
15956 
  def __init__(self, success=None,):
15957 
    self.success = success
15958 
 
15959 
  def read(self, iprot):
15960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15962 
      return
15963 
    iprot.readStructBegin()
15964 
    while True:
15965 
      (fname, ftype, fid) = iprot.readFieldBegin()
15966 
      if ftype == TType.STOP:
15967 
        break
15968 
      if fid == 0:
15969 
        if ftype == TType.BOOL:
15970 
          self.success = iprot.readBool();
15971 
        else:
15972 
          iprot.skip(ftype)
15973 
      else:
15974 
        iprot.skip(ftype)
15975 
      iprot.readFieldEnd()
15976 
    iprot.readStructEnd()
15977 
 
15978 
  def write(self, oprot):
15979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15981 
      return
15982 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15983 
    if self.success is not None:
15984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15985 
      oprot.writeBool(self.success)
15986 
      oprot.writeFieldEnd()
15987 
    oprot.writeFieldStop()
15988 
    oprot.writeStructEnd()
15989 
 
15990 
  def validate(self):
15991 
    return
15992 
 
15993 
 
15994 
  def __repr__(self):
15995 
    L = ['%s=%r' % (key, value)
15996 
      for key, value in self.__dict__.iteritems()]
15997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15998 
 
15999 
  def __eq__(self, other):
16000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16001 
 
16002 
  def __ne__(self, other):
16003 
    return not (self == other)
16004 
 
16005 
class getPrivateDealUser_args:
16006 
  """
16007 
  Attributes:
16008 
   - userId
16009 
  """
16010 
 
16011 
  thrift_spec = (
16012 
    None, # 0
16013 
    (1, TType.I64, 'userId', None, None, ), # 1
16014 
  )
16015 
 
16016 
  def __init__(self, userId=None,):
16017 
    self.userId = userId
16018 
 
16019 
  def read(self, iprot):
16020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16022 
      return
16023 
    iprot.readStructBegin()
16024 
    while True:
16025 
      (fname, ftype, fid) = iprot.readFieldBegin()
16026 
      if ftype == TType.STOP:
16027 
        break
16028 
      if fid == 1:
16029 
        if ftype == TType.I64:
16030 
          self.userId = iprot.readI64();
16031 
        else:
16032 
          iprot.skip(ftype)
16033 
      else:
16034 
        iprot.skip(ftype)
16035 
      iprot.readFieldEnd()
16036 
    iprot.readStructEnd()
16037 
 
16038 
  def write(self, oprot):
16039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16041 
      return
16042 
    oprot.writeStructBegin('getPrivateDealUser_args')
16043 
    if self.userId is not None:
16044 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16045 
      oprot.writeI64(self.userId)
16046 
      oprot.writeFieldEnd()
16047 
    oprot.writeFieldStop()
16048 
    oprot.writeStructEnd()
16049 
 
16050 
  def validate(self):
16051 
    return
16052 
 
16053 
 
16054 
  def __repr__(self):
16055 
    L = ['%s=%r' % (key, value)
16056 
      for key, value in self.__dict__.iteritems()]
16057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16058 
 
16059 
  def __eq__(self, other):
16060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16061 
 
16062 
  def __ne__(self, other):
16063 
    return not (self == other)
16064 
 
16065 
class getPrivateDealUser_result:
16066 
  """
16067 
  Attributes:
16068 
   - success
16069 
  """
16070 
 
16071 
  thrift_spec = (
16072 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16073 
  )
16074 
 
16075 
  def __init__(self, success=None,):
16076 
    self.success = success
16077 
 
16078 
  def read(self, iprot):
16079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16081 
      return
16082 
    iprot.readStructBegin()
16083 
    while True:
16084 
      (fname, ftype, fid) = iprot.readFieldBegin()
16085 
      if ftype == TType.STOP:
16086 
        break
16087 
      if fid == 0:
16088 
        if ftype == TType.STRUCT:
16089 
          self.success = PrivateDealUser()
16090 
          self.success.read(iprot)
16091 
        else:
16092 
          iprot.skip(ftype)
16093 
      else:
16094 
        iprot.skip(ftype)
16095 
      iprot.readFieldEnd()
16096 
    iprot.readStructEnd()
16097 
 
16098 
  def write(self, oprot):
16099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16101 
      return
16102 
    oprot.writeStructBegin('getPrivateDealUser_result')
16103 
    if self.success is not None:
16104 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16105 
      self.success.write(oprot)
16106 
      oprot.writeFieldEnd()
16107 
    oprot.writeFieldStop()
16108 
    oprot.writeStructEnd()
16109 
 
16110 
  def validate(self):
16111 
    return
16112 
 
16113 
 
16114 
  def __repr__(self):
16115 
    L = ['%s=%r' % (key, value)
16116 
      for key, value in self.__dict__.iteritems()]
16117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16118 
 
16119 
  def __eq__(self, other):
16120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16121 
 
16122 
  def __ne__(self, other):
16123 
    return not (self == other)
12696 amit.gupta 16124 
 
16125 
class registerCounter_args:
16126 
  """
16127 
  Attributes:
16128 
   - counter
16129 
   - userId
16130 
  """
16131 
 
16132 
  thrift_spec = (
16133 
    None, # 0
16134 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16135 
    (2, TType.I64, 'userId', None, None, ), # 2
16136 
  )
16137 
 
16138 
  def __init__(self, counter=None, userId=None,):
16139 
    self.counter = counter
16140 
    self.userId = userId
16141 
 
16142 
  def read(self, iprot):
16143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16145 
      return
16146 
    iprot.readStructBegin()
16147 
    while True:
16148 
      (fname, ftype, fid) = iprot.readFieldBegin()
16149 
      if ftype == TType.STOP:
16150 
        break
16151 
      if fid == 1:
16152 
        if ftype == TType.STRUCT:
16153 
          self.counter = Counter()
16154 
          self.counter.read(iprot)
16155 
        else:
16156 
          iprot.skip(ftype)
16157 
      elif fid == 2:
16158 
        if ftype == TType.I64:
16159 
          self.userId = iprot.readI64();
16160 
        else:
16161 
          iprot.skip(ftype)
16162 
      else:
16163 
        iprot.skip(ftype)
16164 
      iprot.readFieldEnd()
16165 
    iprot.readStructEnd()
16166 
 
16167 
  def write(self, oprot):
16168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16170 
      return
16171 
    oprot.writeStructBegin('registerCounter_args')
16172 
    if self.counter is not None:
16173 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16174 
      self.counter.write(oprot)
16175 
      oprot.writeFieldEnd()
16176 
    if self.userId is not None:
16177 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16178 
      oprot.writeI64(self.userId)
16179 
      oprot.writeFieldEnd()
16180 
    oprot.writeFieldStop()
16181 
    oprot.writeStructEnd()
16182 
 
16183 
  def validate(self):
16184 
    return
16185 
 
16186 
 
16187 
  def __repr__(self):
16188 
    L = ['%s=%r' % (key, value)
16189 
      for key, value in self.__dict__.iteritems()]
16190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16191 
 
16192 
  def __eq__(self, other):
16193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16194 
 
16195 
  def __ne__(self, other):
16196 
    return not (self == other)
16197 
 
16198 
class registerCounter_result:
16199 
  """
16200 
  Attributes:
16201 
   - success
16202 
  """
16203 
 
16204 
  thrift_spec = (
16205 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16206 
  )
16207 
 
16208 
  def __init__(self, success=None,):
16209 
    self.success = success
16210 
 
16211 
  def read(self, iprot):
16212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16214 
      return
16215 
    iprot.readStructBegin()
16216 
    while True:
16217 
      (fname, ftype, fid) = iprot.readFieldBegin()
16218 
      if ftype == TType.STOP:
16219 
        break
16220 
      if fid == 0:
16221 
        if ftype == TType.MAP:
16222 
          self.success = {}
16223 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16224 
          for _i229 in xrange(_size225):
16225 
            _key230 = iprot.readString();
16226 
            _val231 = iprot.readString();
16227 
            self.success[_key230] = _val231
16228 
          iprot.readMapEnd()
16229 
        else:
16230 
          iprot.skip(ftype)
16231 
      else:
16232 
        iprot.skip(ftype)
16233 
      iprot.readFieldEnd()
16234 
    iprot.readStructEnd()
16235 
 
16236 
  def write(self, oprot):
16237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16239 
      return
16240 
    oprot.writeStructBegin('registerCounter_result')
16241 
    if self.success is not None:
16242 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16243 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16244 
      for kiter232,viter233 in self.success.items():
16245 
        oprot.writeString(kiter232)
16246 
        oprot.writeString(viter233)
16247 
      oprot.writeMapEnd()
16248 
      oprot.writeFieldEnd()
16249 
    oprot.writeFieldStop()
16250 
    oprot.writeStructEnd()
16251 
 
16252 
  def validate(self):
16253 
    return
16254 
 
16255 
 
16256 
  def __repr__(self):
16257 
    L = ['%s=%r' % (key, value)
16258 
      for key, value in self.__dict__.iteritems()]
16259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16260 
 
16261 
  def __eq__(self, other):
16262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16263 
 
16264 
  def __ne__(self, other):
16265 
    return not (self == other)
12722 amit.gupta 16266 
 
16267 
class searchCounter_args:
16268 
  """
16269 
  Attributes:
16270 
   - type1
16271 
   - searchString
16272 
  """
16273 
 
16274 
  thrift_spec = (
16275 
    None, # 0
16276 
    (1, TType.STRING, 'type1', None, None, ), # 1
16277 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16278 
  )
16279 
 
16280 
  def __init__(self, type1=None, searchString=None,):
16281 
    self.type1 = type1
16282 
    self.searchString = searchString
16283 
 
16284 
  def read(self, iprot):
16285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16287 
      return
16288 
    iprot.readStructBegin()
16289 
    while True:
16290 
      (fname, ftype, fid) = iprot.readFieldBegin()
16291 
      if ftype == TType.STOP:
16292 
        break
16293 
      if fid == 1:
16294 
        if ftype == TType.STRING:
16295 
          self.type1 = iprot.readString();
16296 
        else:
16297 
          iprot.skip(ftype)
16298 
      elif fid == 2:
16299 
        if ftype == TType.STRING:
16300 
          self.searchString = iprot.readString();
16301 
        else:
16302 
          iprot.skip(ftype)
16303 
      else:
16304 
        iprot.skip(ftype)
16305 
      iprot.readFieldEnd()
16306 
    iprot.readStructEnd()
16307 
 
16308 
  def write(self, oprot):
16309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16311 
      return
16312 
    oprot.writeStructBegin('searchCounter_args')
16313 
    if self.type1 is not None:
16314 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16315 
      oprot.writeString(self.type1)
16316 
      oprot.writeFieldEnd()
16317 
    if self.searchString is not None:
16318 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16319 
      oprot.writeString(self.searchString)
16320 
      oprot.writeFieldEnd()
16321 
    oprot.writeFieldStop()
16322 
    oprot.writeStructEnd()
16323 
 
16324 
  def validate(self):
16325 
    return
16326 
 
16327 
 
16328 
  def __repr__(self):
16329 
    L = ['%s=%r' % (key, value)
16330 
      for key, value in self.__dict__.iteritems()]
16331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16332 
 
16333 
  def __eq__(self, other):
16334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16335 
 
16336 
  def __ne__(self, other):
16337 
    return not (self == other)
16338 
 
16339 
class searchCounter_result:
16340 
  """
16341 
  Attributes:
16342 
   - success
16343 
  """
16344 
 
16345 
  thrift_spec = (
16346 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16347 
  )
16348 
 
16349 
  def __init__(self, success=None,):
16350 
    self.success = success
16351 
 
16352 
  def read(self, iprot):
16353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16355 
      return
16356 
    iprot.readStructBegin()
16357 
    while True:
16358 
      (fname, ftype, fid) = iprot.readFieldBegin()
16359 
      if ftype == TType.STOP:
16360 
        break
16361 
      if fid == 0:
16362 
        if ftype == TType.LIST:
16363 
          self.success = []
16364 
          (_etype237, _size234) = iprot.readListBegin()
16365 
          for _i238 in xrange(_size234):
16366 
            _elem239 = Counter()
16367 
            _elem239.read(iprot)
16368 
            self.success.append(_elem239)
16369 
          iprot.readListEnd()
16370 
        else:
16371 
          iprot.skip(ftype)
16372 
      else:
16373 
        iprot.skip(ftype)
16374 
      iprot.readFieldEnd()
16375 
    iprot.readStructEnd()
16376 
 
16377 
  def write(self, oprot):
16378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16380 
      return
16381 
    oprot.writeStructBegin('searchCounter_result')
16382 
    if self.success is not None:
16383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16385 
      for iter240 in self.success:
16386 
        iter240.write(oprot)
16387 
      oprot.writeListEnd()
16388 
      oprot.writeFieldEnd()
16389 
    oprot.writeFieldStop()
16390 
    oprot.writeStructEnd()
16391 
 
16392 
  def validate(self):
16393 
    return
16394 
 
16395 
 
16396 
  def __repr__(self):
16397 
    L = ['%s=%r' % (key, value)
16398 
      for key, value in self.__dict__.iteritems()]
16399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16400 
 
16401 
  def __eq__(self, other):
16402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16403 
 
16404 
  def __ne__(self, other):
16405 
    return not (self == other)
16406 
 
18977 amit.gupta 16407 
class getCounterByUserId_args:
16408 
  """
16409 
  Attributes:
16410 
   - userId
16411 
  """
16412 
 
16413 
  thrift_spec = (
16414 
    None, # 0
16415 
    (1, TType.I64, 'userId', None, None, ), # 1
16416 
  )
16417 
 
16418 
  def __init__(self, userId=None,):
16419 
    self.userId = userId
16420 
 
16421 
  def read(self, iprot):
16422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16424 
      return
16425 
    iprot.readStructBegin()
16426 
    while True:
16427 
      (fname, ftype, fid) = iprot.readFieldBegin()
16428 
      if ftype == TType.STOP:
16429 
        break
16430 
      if fid == 1:
16431 
        if ftype == TType.I64:
16432 
          self.userId = iprot.readI64();
16433 
        else:
16434 
          iprot.skip(ftype)
16435 
      else:
16436 
        iprot.skip(ftype)
16437 
      iprot.readFieldEnd()
16438 
    iprot.readStructEnd()
16439 
 
16440 
  def write(self, oprot):
16441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16443 
      return
16444 
    oprot.writeStructBegin('getCounterByUserId_args')
16445 
    if self.userId is not None:
16446 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16447 
      oprot.writeI64(self.userId)
16448 
      oprot.writeFieldEnd()
16449 
    oprot.writeFieldStop()
16450 
    oprot.writeStructEnd()
16451 
 
16452 
  def validate(self):
16453 
    return
16454 
 
16455 
 
16456 
  def __repr__(self):
16457 
    L = ['%s=%r' % (key, value)
16458 
      for key, value in self.__dict__.iteritems()]
16459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16460 
 
16461 
  def __eq__(self, other):
16462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16463 
 
16464 
  def __ne__(self, other):
16465 
    return not (self == other)
16466 
 
16467 
class getCounterByUserId_result:
16468 
  """
16469 
  Attributes:
16470 
   - success
16471 
  """
16472 
 
16473 
  thrift_spec = (
16474 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16475 
  )
16476 
 
16477 
  def __init__(self, success=None,):
16478 
    self.success = success
16479 
 
16480 
  def read(self, iprot):
16481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16483 
      return
16484 
    iprot.readStructBegin()
16485 
    while True:
16486 
      (fname, ftype, fid) = iprot.readFieldBegin()
16487 
      if ftype == TType.STOP:
16488 
        break
16489 
      if fid == 0:
16490 
        if ftype == TType.STRUCT:
16491 
          self.success = Counter()
16492 
          self.success.read(iprot)
16493 
        else:
16494 
          iprot.skip(ftype)
16495 
      else:
16496 
        iprot.skip(ftype)
16497 
      iprot.readFieldEnd()
16498 
    iprot.readStructEnd()
16499 
 
16500 
  def write(self, oprot):
16501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16503 
      return
16504 
    oprot.writeStructBegin('getCounterByUserId_result')
16505 
    if self.success is not None:
16506 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16507 
      self.success.write(oprot)
16508 
      oprot.writeFieldEnd()
16509 
    oprot.writeFieldStop()
16510 
    oprot.writeStructEnd()
16511 
 
16512 
  def validate(self):
16513 
    return
16514 
 
16515 
 
16516 
  def __repr__(self):
16517 
    L = ['%s=%r' % (key, value)
16518 
      for key, value in self.__dict__.iteritems()]
16519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16520 
 
16521 
  def __eq__(self, other):
16522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16523 
 
16524 
  def __ne__(self, other):
16525 
    return not (self == other)
16526 
 
12722 amit.gupta 16527 
class getAllUsersByCounter_args:
16528 
  """
16529 
  Attributes:
16530 
   - counterId
16531 
  """
16532 
 
16533 
  thrift_spec = (
16534 
    None, # 0
16535 
    (1, TType.I64, 'counterId', None, None, ), # 1
16536 
  )
16537 
 
16538 
  def __init__(self, counterId=None,):
16539 
    self.counterId = counterId
16540 
 
16541 
  def read(self, iprot):
16542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16544 
      return
16545 
    iprot.readStructBegin()
16546 
    while True:
16547 
      (fname, ftype, fid) = iprot.readFieldBegin()
16548 
      if ftype == TType.STOP:
16549 
        break
16550 
      if fid == 1:
16551 
        if ftype == TType.I64:
16552 
          self.counterId = iprot.readI64();
16553 
        else:
16554 
          iprot.skip(ftype)
16555 
      else:
16556 
        iprot.skip(ftype)
16557 
      iprot.readFieldEnd()
16558 
    iprot.readStructEnd()
16559 
 
16560 
  def write(self, oprot):
16561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16563 
      return
16564 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16565 
    if self.counterId is not None:
16566 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16567 
      oprot.writeI64(self.counterId)
16568 
      oprot.writeFieldEnd()
16569 
    oprot.writeFieldStop()
16570 
    oprot.writeStructEnd()
16571 
 
16572 
  def validate(self):
16573 
    return
16574 
 
16575 
 
16576 
  def __repr__(self):
16577 
    L = ['%s=%r' % (key, value)
16578 
      for key, value in self.__dict__.iteritems()]
16579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16580 
 
16581 
  def __eq__(self, other):
16582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16583 
 
16584 
  def __ne__(self, other):
16585 
    return not (self == other)
16586 
 
16587 
class getAllUsersByCounter_result:
16588 
  """
16589 
  Attributes:
16590 
   - success
16591 
  """
16592 
 
16593 
  thrift_spec = (
16594 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16595 
  )
16596 
 
16597 
  def __init__(self, success=None,):
16598 
    self.success = success
16599 
 
16600 
  def read(self, iprot):
16601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16603 
      return
16604 
    iprot.readStructBegin()
16605 
    while True:
16606 
      (fname, ftype, fid) = iprot.readFieldBegin()
16607 
      if ftype == TType.STOP:
16608 
        break
16609 
      if fid == 0:
16610 
        if ftype == TType.LIST:
16611 
          self.success = []
16612 
          (_etype244, _size241) = iprot.readListBegin()
16613 
          for _i245 in xrange(_size241):
16614 
            _elem246 = User()
16615 
            _elem246.read(iprot)
16616 
            self.success.append(_elem246)
16617 
          iprot.readListEnd()
16618 
        else:
16619 
          iprot.skip(ftype)
16620 
      else:
16621 
        iprot.skip(ftype)
16622 
      iprot.readFieldEnd()
16623 
    iprot.readStructEnd()
16624 
 
16625 
  def write(self, oprot):
16626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16628 
      return
16629 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16630 
    if self.success is not None:
16631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16633 
      for iter247 in self.success:
16634 
        iter247.write(oprot)
16635 
      oprot.writeListEnd()
16636 
      oprot.writeFieldEnd()
16637 
    oprot.writeFieldStop()
16638 
    oprot.writeStructEnd()
16639 
 
16640 
  def validate(self):
16641 
    return
16642 
 
16643 
 
16644 
  def __repr__(self):
16645 
    L = ['%s=%r' % (key, value)
16646 
      for key, value in self.__dict__.iteritems()]
16647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16648 
 
16649 
  def __eq__(self, other):
16650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16651 
 
16652 
  def __ne__(self, other):
16653 
    return not (self == other)
15251 manish.sha 16654 
 
16655 
class getActiveAccessTokenForUser_args:
16656 
  """
16657 
  Attributes:
16658 
   - userId
16659 
   - source
16660 
  """
16661 
 
16662 
  thrift_spec = (
16663 
    None, # 0
16664 
    (1, TType.I64, 'userId', None, None, ), # 1
16665 
    (2, TType.STRING, 'source', None, None, ), # 2
16666 
  )
16667 
 
16668 
  def __init__(self, userId=None, source=None,):
16669 
    self.userId = userId
16670 
    self.source = source
16671 
 
16672 
  def read(self, iprot):
16673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16675 
      return
16676 
    iprot.readStructBegin()
16677 
    while True:
16678 
      (fname, ftype, fid) = iprot.readFieldBegin()
16679 
      if ftype == TType.STOP:
16680 
        break
16681 
      if fid == 1:
16682 
        if ftype == TType.I64:
16683 
          self.userId = iprot.readI64();
16684 
        else:
16685 
          iprot.skip(ftype)
16686 
      elif fid == 2:
16687 
        if ftype == TType.STRING:
16688 
          self.source = iprot.readString();
16689 
        else:
16690 
          iprot.skip(ftype)
16691 
      else:
16692 
        iprot.skip(ftype)
16693 
      iprot.readFieldEnd()
16694 
    iprot.readStructEnd()
16695 
 
16696 
  def write(self, oprot):
16697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16699 
      return
16700 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16701 
    if self.userId is not None:
16702 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16703 
      oprot.writeI64(self.userId)
16704 
      oprot.writeFieldEnd()
16705 
    if self.source is not None:
16706 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16707 
      oprot.writeString(self.source)
16708 
      oprot.writeFieldEnd()
16709 
    oprot.writeFieldStop()
16710 
    oprot.writeStructEnd()
16711 
 
16712 
  def validate(self):
16713 
    return
16714 
 
16715 
 
16716 
  def __repr__(self):
16717 
    L = ['%s=%r' % (key, value)
16718 
      for key, value in self.__dict__.iteritems()]
16719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16720 
 
16721 
  def __eq__(self, other):
16722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16723 
 
16724 
  def __ne__(self, other):
16725 
    return not (self == other)
16726 
 
16727 
class getActiveAccessTokenForUser_result:
16728 
  """
16729 
  Attributes:
16730 
   - success
16731 
  """
16732 
 
16733 
  thrift_spec = (
16734 
    (0, TType.STRING, 'success', None, None, ), # 0
16735 
  )
16736 
 
16737 
  def __init__(self, success=None,):
16738 
    self.success = success
16739 
 
16740 
  def read(self, iprot):
16741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16743 
      return
16744 
    iprot.readStructBegin()
16745 
    while True:
16746 
      (fname, ftype, fid) = iprot.readFieldBegin()
16747 
      if ftype == TType.STOP:
16748 
        break
16749 
      if fid == 0:
16750 
        if ftype == TType.STRING:
16751 
          self.success = iprot.readString();
16752 
        else:
16753 
          iprot.skip(ftype)
16754 
      else:
16755 
        iprot.skip(ftype)
16756 
      iprot.readFieldEnd()
16757 
    iprot.readStructEnd()
16758 
 
16759 
  def write(self, oprot):
16760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16762 
      return
16763 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16764 
    if self.success is not None:
16765 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16766 
      oprot.writeString(self.success)
16767 
      oprot.writeFieldEnd()
16768 
    oprot.writeFieldStop()
16769 
    oprot.writeStructEnd()
16770 
 
16771 
  def validate(self):
16772 
    return
16773 
 
16774 
 
16775 
  def __repr__(self):
16776 
    L = ['%s=%r' % (key, value)
16777 
      for key, value in self.__dict__.iteritems()]
16778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16779 
 
16780 
  def __eq__(self, other):
16781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16782 
 
16783 
  def __ne__(self, other):
16784 
    return not (self == other)
16785 
 
16786 
class validateAccessToken_args:
16787 
  """
16788 
  Attributes:
16789 
   - accessToken
16790 
  """
16791 
 
16792 
  thrift_spec = (
16793 
    None, # 0
16794 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16795 
  )
16796 
 
16797 
  def __init__(self, accessToken=None,):
16798 
    self.accessToken = accessToken
16799 
 
16800 
  def read(self, iprot):
16801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16803 
      return
16804 
    iprot.readStructBegin()
16805 
    while True:
16806 
      (fname, ftype, fid) = iprot.readFieldBegin()
16807 
      if ftype == TType.STOP:
16808 
        break
16809 
      if fid == 1:
16810 
        if ftype == TType.STRING:
16811 
          self.accessToken = iprot.readString();
16812 
        else:
16813 
          iprot.skip(ftype)
16814 
      else:
16815 
        iprot.skip(ftype)
16816 
      iprot.readFieldEnd()
16817 
    iprot.readStructEnd()
16818 
 
16819 
  def write(self, oprot):
16820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16822 
      return
16823 
    oprot.writeStructBegin('validateAccessToken_args')
16824 
    if self.accessToken is not None:
16825 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16826 
      oprot.writeString(self.accessToken)
16827 
      oprot.writeFieldEnd()
16828 
    oprot.writeFieldStop()
16829 
    oprot.writeStructEnd()
16830 
 
16831 
  def validate(self):
16832 
    return
16833 
 
16834 
 
16835 
  def __repr__(self):
16836 
    L = ['%s=%r' % (key, value)
16837 
      for key, value in self.__dict__.iteritems()]
16838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16839 
 
16840 
  def __eq__(self, other):
16841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16842 
 
16843 
  def __ne__(self, other):
16844 
    return not (self == other)
16845 
 
16846 
class validateAccessToken_result:
16847 
  """
16848 
  Attributes:
16849 
   - success
16850 
  """
16851 
 
16852 
  thrift_spec = (
16853 
    (0, TType.BOOL, 'success', None, None, ), # 0
16854 
  )
16855 
 
16856 
  def __init__(self, success=None,):
16857 
    self.success = success
16858 
 
16859 
  def read(self, iprot):
16860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16862 
      return
16863 
    iprot.readStructBegin()
16864 
    while True:
16865 
      (fname, ftype, fid) = iprot.readFieldBegin()
16866 
      if ftype == TType.STOP:
16867 
        break
16868 
      if fid == 0:
16869 
        if ftype == TType.BOOL:
16870 
          self.success = iprot.readBool();
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      else:
16874 
        iprot.skip(ftype)
16875 
      iprot.readFieldEnd()
16876 
    iprot.readStructEnd()
16877 
 
16878 
  def write(self, oprot):
16879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16881 
      return
16882 
    oprot.writeStructBegin('validateAccessToken_result')
16883 
    if self.success is not None:
16884 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16885 
      oprot.writeBool(self.success)
16886 
      oprot.writeFieldEnd()
16887 
    oprot.writeFieldStop()
16888 
    oprot.writeStructEnd()
16889 
 
16890 
  def validate(self):
16891 
    return
16892 
 
16893 
 
16894 
  def __repr__(self):
16895 
    L = ['%s=%r' % (key, value)
16896 
      for key, value in self.__dict__.iteritems()]
16897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16898 
 
16899 
  def __eq__(self, other):
16900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16901 
 
16902 
  def __ne__(self, other):
16903 
    return not (self == other)
17782 amit.gupta 16904 
 
16905 
class addItemsToCart_args:
16906 
  """
16907 
  Attributes:
16908 
   - cartId
16909 
   - itemQty
16910 
   - couponCode
16911 
  """
16912 
 
16913 
  thrift_spec = (
16914 
    None, # 0
16915 
    (1, TType.I64, 'cartId', None, None, ), # 1
16916 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16917 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16918 
  )
16919 
 
16920 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16921 
    self.cartId = cartId
16922 
    self.itemQty = itemQty
16923 
    self.couponCode = couponCode
16924 
 
16925 
  def read(self, iprot):
16926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16928 
      return
16929 
    iprot.readStructBegin()
16930 
    while True:
16931 
      (fname, ftype, fid) = iprot.readFieldBegin()
16932 
      if ftype == TType.STOP:
16933 
        break
16934 
      if fid == 1:
16935 
        if ftype == TType.I64:
16936 
          self.cartId = iprot.readI64();
16937 
        else:
16938 
          iprot.skip(ftype)
16939 
      elif fid == 2:
16940 
        if ftype == TType.LIST:
16941 
          self.itemQty = []
16942 
          (_etype251, _size248) = iprot.readListBegin()
16943 
          for _i252 in xrange(_size248):
16944 
            _elem253 = ItemQuantity()
16945 
            _elem253.read(iprot)
16946 
            self.itemQty.append(_elem253)
16947 
          iprot.readListEnd()
16948 
        else:
16949 
          iprot.skip(ftype)
16950 
      elif fid == 3:
16951 
        if ftype == TType.STRING:
16952 
          self.couponCode = iprot.readString();
16953 
        else:
16954 
          iprot.skip(ftype)
16955 
      else:
16956 
        iprot.skip(ftype)
16957 
      iprot.readFieldEnd()
16958 
    iprot.readStructEnd()
16959 
 
16960 
  def write(self, oprot):
16961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16963 
      return
16964 
    oprot.writeStructBegin('addItemsToCart_args')
16965 
    if self.cartId is not None:
16966 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16967 
      oprot.writeI64(self.cartId)
16968 
      oprot.writeFieldEnd()
16969 
    if self.itemQty is not None:
16970 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16971 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16972 
      for iter254 in self.itemQty:
16973 
        iter254.write(oprot)
16974 
      oprot.writeListEnd()
16975 
      oprot.writeFieldEnd()
16976 
    if self.couponCode is not None:
16977 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16978 
      oprot.writeString(self.couponCode)
16979 
      oprot.writeFieldEnd()
16980 
    oprot.writeFieldStop()
16981 
    oprot.writeStructEnd()
16982 
 
16983 
  def validate(self):
16984 
    return
16985 
 
16986 
 
16987 
  def __repr__(self):
16988 
    L = ['%s=%r' % (key, value)
16989 
      for key, value in self.__dict__.iteritems()]
16990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16991 
 
16992 
  def __eq__(self, other):
16993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16994 
 
16995 
  def __ne__(self, other):
16996 
    return not (self == other)
16997 
 
16998 
class addItemsToCart_result:
16999 
  """
17000 
  Attributes:
17001 
   - success
17002 
  """
17003 
 
17004 
  thrift_spec = (
17005 
    (0, TType.BOOL, 'success', None, None, ), # 0
17006 
  )
17007 
 
17008 
  def __init__(self, success=None,):
17009 
    self.success = success
17010 
 
17011 
  def read(self, iprot):
17012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17014 
      return
17015 
    iprot.readStructBegin()
17016 
    while True:
17017 
      (fname, ftype, fid) = iprot.readFieldBegin()
17018 
      if ftype == TType.STOP:
17019 
        break
17020 
      if fid == 0:
17021 
        if ftype == TType.BOOL:
17022 
          self.success = iprot.readBool();
17023 
        else:
17024 
          iprot.skip(ftype)
17025 
      else:
17026 
        iprot.skip(ftype)
17027 
      iprot.readFieldEnd()
17028 
    iprot.readStructEnd()
17029 
 
17030 
  def write(self, oprot):
17031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17033 
      return
17034 
    oprot.writeStructBegin('addItemsToCart_result')
17035 
    if self.success is not None:
17036 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17037 
      oprot.writeBool(self.success)
17038 
      oprot.writeFieldEnd()
17039 
    oprot.writeFieldStop()
17040 
    oprot.writeStructEnd()
17041 
 
17042 
  def validate(self):
17043 
    return
17044 
 
17045 
 
17046 
  def __repr__(self):
17047 
    L = ['%s=%r' % (key, value)
17048 
      for key, value in self.__dict__.iteritems()]
17049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17050 
 
17051 
  def __eq__(self, other):
17052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17053 
 
17054 
  def __ne__(self, other):
17055 
    return not (self == other)
17056 
 
17057 
class validateCartNew_args:
17058 
  """
17059 
  Attributes:
17060 
   - cartId
17061 
   - pinCode
17062 
   - sourceId
17063 
  """
17064 
 
17065 
  thrift_spec = (
17066 
    None, # 0
17067 
    (1, TType.I64, 'cartId', None, None, ), # 1
17068 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17069 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17070 
  )
17071 
 
17072 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17073 
    self.cartId = cartId
17074 
    self.pinCode = pinCode
17075 
    self.sourceId = sourceId
17076 
 
17077 
  def read(self, iprot):
17078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17080 
      return
17081 
    iprot.readStructBegin()
17082 
    while True:
17083 
      (fname, ftype, fid) = iprot.readFieldBegin()
17084 
      if ftype == TType.STOP:
17085 
        break
17086 
      if fid == 1:
17087 
        if ftype == TType.I64:
17088 
          self.cartId = iprot.readI64();
17089 
        else:
17090 
          iprot.skip(ftype)
17091 
      elif fid == 2:
17092 
        if ftype == TType.STRING:
17093 
          self.pinCode = iprot.readString();
17094 
        else:
17095 
          iprot.skip(ftype)
17096 
      elif fid == 3:
17097 
        if ftype == TType.I64:
17098 
          self.sourceId = iprot.readI64();
17099 
        else:
17100 
          iprot.skip(ftype)
17101 
      else:
17102 
        iprot.skip(ftype)
17103 
      iprot.readFieldEnd()
17104 
    iprot.readStructEnd()
17105 
 
17106 
  def write(self, oprot):
17107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17109 
      return
17110 
    oprot.writeStructBegin('validateCartNew_args')
17111 
    if self.cartId is not None:
17112 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17113 
      oprot.writeI64(self.cartId)
17114 
      oprot.writeFieldEnd()
17115 
    if self.pinCode is not None:
17116 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17117 
      oprot.writeString(self.pinCode)
17118 
      oprot.writeFieldEnd()
17119 
    if self.sourceId is not None:
17120 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17121 
      oprot.writeI64(self.sourceId)
17122 
      oprot.writeFieldEnd()
17123 
    oprot.writeFieldStop()
17124 
    oprot.writeStructEnd()
17125 
 
17126 
  def validate(self):
17127 
    return
17128 
 
17129 
 
17130 
  def __repr__(self):
17131 
    L = ['%s=%r' % (key, value)
17132 
      for key, value in self.__dict__.iteritems()]
17133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17134 
 
17135 
  def __eq__(self, other):
17136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17137 
 
17138 
  def __ne__(self, other):
17139 
    return not (self == other)
17140 
 
17141 
class validateCartNew_result:
17142 
  """
17143 
  Attributes:
17144 
   - success
17145 
  """
17146 
 
17147 
  thrift_spec = (
17148 
    (0, TType.STRING, 'success', None, None, ), # 0
17149 
  )
17150 
 
17151 
  def __init__(self, success=None,):
17152 
    self.success = success
17153 
 
17154 
  def read(self, iprot):
17155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17157 
      return
17158 
    iprot.readStructBegin()
17159 
    while True:
17160 
      (fname, ftype, fid) = iprot.readFieldBegin()
17161 
      if ftype == TType.STOP:
17162 
        break
17163 
      if fid == 0:
17164 
        if ftype == TType.STRING:
17165 
          self.success = iprot.readString();
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      else:
17169 
        iprot.skip(ftype)
17170 
      iprot.readFieldEnd()
17171 
    iprot.readStructEnd()
17172 
 
17173 
  def write(self, oprot):
17174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17176 
      return
17177 
    oprot.writeStructBegin('validateCartNew_result')
17178 
    if self.success is not None:
17179 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17180 
      oprot.writeString(self.success)
17181 
      oprot.writeFieldEnd()
17182 
    oprot.writeFieldStop()
17183 
    oprot.writeStructEnd()
17184 
 
17185 
  def validate(self):
17186 
    return
17187 
 
17188 
 
17189 
  def __repr__(self):
17190 
    L = ['%s=%r' % (key, value)
17191 
      for key, value in self.__dict__.iteritems()]
17192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17193 
 
17194 
  def __eq__(self, other):
17195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17196 
 
17197 
  def __ne__(self, other):
17198 
    return not (self == other)
18530 manish.sha 17199 
 
18644 manish.sha 17200 
class isAddressEditableForCounter_args:
18530 manish.sha 17201 
  """
17202 
  Attributes:
17203 
   - userId
17204 
  """
17205 
 
17206 
  thrift_spec = (
17207 
    None, # 0
17208 
    (1, TType.I64, 'userId', None, None, ), # 1
17209 
  )
17210 
 
17211 
  def __init__(self, userId=None,):
17212 
    self.userId = userId
17213 
 
17214 
  def read(self, iprot):
17215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17217 
      return
17218 
    iprot.readStructBegin()
17219 
    while True:
17220 
      (fname, ftype, fid) = iprot.readFieldBegin()
17221 
      if ftype == TType.STOP:
17222 
        break
17223 
      if fid == 1:
17224 
        if ftype == TType.I64:
17225 
          self.userId = iprot.readI64();
17226 
        else:
17227 
          iprot.skip(ftype)
17228 
      else:
17229 
        iprot.skip(ftype)
17230 
      iprot.readFieldEnd()
17231 
    iprot.readStructEnd()
17232 
 
17233 
  def write(self, oprot):
17234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17236 
      return
18644 manish.sha 17237 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17238 
    if self.userId is not None:
17239 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17240 
      oprot.writeI64(self.userId)
17241 
      oprot.writeFieldEnd()
17242 
    oprot.writeFieldStop()
17243 
    oprot.writeStructEnd()
17244 
 
17245 
  def validate(self):
17246 
    return
17247 
 
17248 
 
17249 
  def __repr__(self):
17250 
    L = ['%s=%r' % (key, value)
17251 
      for key, value in self.__dict__.iteritems()]
17252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17253 
 
17254 
  def __eq__(self, other):
17255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17256 
 
17257 
  def __ne__(self, other):
17258 
    return not (self == other)
17259 
 
18644 manish.sha 17260 
class isAddressEditableForCounter_result:
18530 manish.sha 17261 
  """
17262 
  Attributes:
17263 
   - success
17264 
  """
17265 
 
17266 
  thrift_spec = (
17267 
    (0, TType.BOOL, 'success', None, None, ), # 0
17268 
  )
17269 
 
17270 
  def __init__(self, success=None,):
17271 
    self.success = success
17272 
 
17273 
  def read(self, iprot):
17274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17276 
      return
17277 
    iprot.readStructBegin()
17278 
    while True:
17279 
      (fname, ftype, fid) = iprot.readFieldBegin()
17280 
      if ftype == TType.STOP:
17281 
        break
17282 
      if fid == 0:
17283 
        if ftype == TType.BOOL:
17284 
          self.success = iprot.readBool();
17285 
        else:
17286 
          iprot.skip(ftype)
17287 
      else:
17288 
        iprot.skip(ftype)
17289 
      iprot.readFieldEnd()
17290 
    iprot.readStructEnd()
17291 
 
17292 
  def write(self, oprot):
17293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17295 
      return
18644 manish.sha 17296 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17297 
    if self.success is not None:
17298 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17299 
      oprot.writeBool(self.success)
17300 
      oprot.writeFieldEnd()
17301 
    oprot.writeFieldStop()
17302 
    oprot.writeStructEnd()
17303 
 
17304 
  def validate(self):
17305 
    return
17306 
 
17307 
 
17308 
  def __repr__(self):
17309 
    L = ['%s=%r' % (key, value)
17310 
      for key, value in self.__dict__.iteritems()]
17311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17312 
 
17313 
  def __eq__(self, other):
17314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17315 
 
17316 
  def __ne__(self, other):
17317 
    return not (self == other)
17318 
 
17319 
class getBillingAddressForUser_args:
17320 
  """
17321 
  Attributes:
17322 
   - userId
17323 
  """
17324 
 
17325 
  thrift_spec = (
17326 
    None, # 0
17327 
    (1, TType.I64, 'userId', None, None, ), # 1
17328 
  )
17329 
 
17330 
  def __init__(self, userId=None,):
17331 
    self.userId = userId
17332 
 
17333 
  def read(self, iprot):
17334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17336 
      return
17337 
    iprot.readStructBegin()
17338 
    while True:
17339 
      (fname, ftype, fid) = iprot.readFieldBegin()
17340 
      if ftype == TType.STOP:
17341 
        break
17342 
      if fid == 1:
17343 
        if ftype == TType.I64:
17344 
          self.userId = iprot.readI64();
17345 
        else:
17346 
          iprot.skip(ftype)
17347 
      else:
17348 
        iprot.skip(ftype)
17349 
      iprot.readFieldEnd()
17350 
    iprot.readStructEnd()
17351 
 
17352 
  def write(self, oprot):
17353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17355 
      return
17356 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17357 
    if self.userId is not None:
17358 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17359 
      oprot.writeI64(self.userId)
17360 
      oprot.writeFieldEnd()
17361 
    oprot.writeFieldStop()
17362 
    oprot.writeStructEnd()
17363 
 
17364 
  def validate(self):
17365 
    return
17366 
 
17367 
 
17368 
  def __repr__(self):
17369 
    L = ['%s=%r' % (key, value)
17370 
      for key, value in self.__dict__.iteritems()]
17371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17372 
 
17373 
  def __eq__(self, other):
17374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17375 
 
17376 
  def __ne__(self, other):
17377 
    return not (self == other)
17378 
 
17379 
class getBillingAddressForUser_result:
17380 
  """
17381 
  Attributes:
17382 
   - success
17383 
  """
17384 
 
17385 
  thrift_spec = (
17386 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17387 
  )
17388 
 
17389 
  def __init__(self, success=None,):
17390 
    self.success = success
17391 
 
17392 
  def read(self, iprot):
17393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17395 
      return
17396 
    iprot.readStructBegin()
17397 
    while True:
17398 
      (fname, ftype, fid) = iprot.readFieldBegin()
17399 
      if ftype == TType.STOP:
17400 
        break
17401 
      if fid == 0:
17402 
        if ftype == TType.STRUCT:
17403 
          self.success = Address()
17404 
          self.success.read(iprot)
17405 
        else:
17406 
          iprot.skip(ftype)
17407 
      else:
17408 
        iprot.skip(ftype)
17409 
      iprot.readFieldEnd()
17410 
    iprot.readStructEnd()
17411 
 
17412 
  def write(self, oprot):
17413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17415 
      return
17416 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17417 
    if self.success is not None:
17418 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17419 
      self.success.write(oprot)
17420 
      oprot.writeFieldEnd()
17421 
    oprot.writeFieldStop()
17422 
    oprot.writeStructEnd()
17423 
 
17424 
  def validate(self):
17425 
    return
17426 
 
17427 
 
17428 
  def __repr__(self):
17429 
    L = ['%s=%r' % (key, value)
17430 
      for key, value in self.__dict__.iteritems()]
17431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17432 
 
17433 
  def __eq__(self, other):
17434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17435 
 
17436 
  def __ne__(self, other):
17437 
    return not (self == other)
18590 manish.sha 17438 
 
17439 
class isCreditorAssigned_args:
17440 
  """
17441 
  Attributes:
17442 
   - userId
17443 
  """
17444 
 
17445 
  thrift_spec = (
17446 
    None, # 0
17447 
    (1, TType.I64, 'userId', None, None, ), # 1
17448 
  )
17449 
 
17450 
  def __init__(self, userId=None,):
17451 
    self.userId = userId
17452 
 
17453 
  def read(self, iprot):
17454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17456 
      return
17457 
    iprot.readStructBegin()
17458 
    while True:
17459 
      (fname, ftype, fid) = iprot.readFieldBegin()
17460 
      if ftype == TType.STOP:
17461 
        break
17462 
      if fid == 1:
17463 
        if ftype == TType.I64:
17464 
          self.userId = iprot.readI64();
17465 
        else:
17466 
          iprot.skip(ftype)
17467 
      else:
17468 
        iprot.skip(ftype)
17469 
      iprot.readFieldEnd()
17470 
    iprot.readStructEnd()
17471 
 
17472 
  def write(self, oprot):
17473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17475 
      return
17476 
    oprot.writeStructBegin('isCreditorAssigned_args')
17477 
    if self.userId is not None:
17478 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17479 
      oprot.writeI64(self.userId)
17480 
      oprot.writeFieldEnd()
17481 
    oprot.writeFieldStop()
17482 
    oprot.writeStructEnd()
17483 
 
17484 
  def validate(self):
17485 
    return
17486 
 
17487 
 
17488 
  def __repr__(self):
17489 
    L = ['%s=%r' % (key, value)
17490 
      for key, value in self.__dict__.iteritems()]
17491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17492 
 
17493 
  def __eq__(self, other):
17494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17495 
 
17496 
  def __ne__(self, other):
17497 
    return not (self == other)
17498 
 
17499 
class isCreditorAssigned_result:
17500 
  """
17501 
  Attributes:
17502 
   - success
17503 
  """
17504 
 
17505 
  thrift_spec = (
17506 
    (0, TType.BOOL, 'success', None, None, ), # 0
17507 
  )
17508 
 
17509 
  def __init__(self, success=None,):
17510 
    self.success = success
17511 
 
17512 
  def read(self, iprot):
17513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17515 
      return
17516 
    iprot.readStructBegin()
17517 
    while True:
17518 
      (fname, ftype, fid) = iprot.readFieldBegin()
17519 
      if ftype == TType.STOP:
17520 
        break
17521 
      if fid == 0:
17522 
        if ftype == TType.BOOL:
17523 
          self.success = iprot.readBool();
17524 
        else:
17525 
          iprot.skip(ftype)
17526 
      else:
17527 
        iprot.skip(ftype)
17528 
      iprot.readFieldEnd()
17529 
    iprot.readStructEnd()
17530 
 
17531 
  def write(self, oprot):
17532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17534 
      return
17535 
    oprot.writeStructBegin('isCreditorAssigned_result')
17536 
    if self.success is not None:
17537 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17538 
      oprot.writeBool(self.success)
17539 
      oprot.writeFieldEnd()
17540 
    oprot.writeFieldStop()
17541 
    oprot.writeStructEnd()
17542 
 
17543 
  def validate(self):
17544 
    return
17545 
 
17546 
 
17547 
  def __repr__(self):
17548 
    L = ['%s=%r' % (key, value)
17549 
      for key, value in self.__dict__.iteritems()]
17550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17551 
 
17552 
  def __eq__(self, other):
17553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17554 
 
17555 
  def __ne__(self, other):
17556 
    return not (self == other)
18735 manish.sha 17557 
 
17558 
class isTaxInvoiceEnabledUser_args:
17559 
  """
17560 
  Attributes:
17561 
   - userId
17562 
  """
17563 
 
17564 
  thrift_spec = (
17565 
    None, # 0
17566 
    (1, TType.I64, 'userId', None, None, ), # 1
17567 
  )
17568 
 
17569 
  def __init__(self, userId=None,):
17570 
    self.userId = userId
17571 
 
17572 
  def read(self, iprot):
17573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17575 
      return
17576 
    iprot.readStructBegin()
17577 
    while True:
17578 
      (fname, ftype, fid) = iprot.readFieldBegin()
17579 
      if ftype == TType.STOP:
17580 
        break
17581 
      if fid == 1:
17582 
        if ftype == TType.I64:
17583 
          self.userId = iprot.readI64();
17584 
        else:
17585 
          iprot.skip(ftype)
17586 
      else:
17587 
        iprot.skip(ftype)
17588 
      iprot.readFieldEnd()
17589 
    iprot.readStructEnd()
17590 
 
17591 
  def write(self, oprot):
17592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17594 
      return
17595 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17596 
    if self.userId is not None:
17597 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17598 
      oprot.writeI64(self.userId)
17599 
      oprot.writeFieldEnd()
17600 
    oprot.writeFieldStop()
17601 
    oprot.writeStructEnd()
17602 
 
17603 
  def validate(self):
17604 
    return
17605 
 
17606 
 
17607 
  def __repr__(self):
17608 
    L = ['%s=%r' % (key, value)
17609 
      for key, value in self.__dict__.iteritems()]
17610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17611 
 
17612 
  def __eq__(self, other):
17613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17614 
 
17615 
  def __ne__(self, other):
17616 
    return not (self == other)
17617 
 
17618 
class isTaxInvoiceEnabledUser_result:
17619 
  """
17620 
  Attributes:
17621 
   - success
17622 
  """
17623 
 
17624 
  thrift_spec = (
17625 
    (0, TType.BOOL, 'success', None, None, ), # 0
17626 
  )
17627 
 
17628 
  def __init__(self, success=None,):
17629 
    self.success = success
17630 
 
17631 
  def read(self, iprot):
17632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17634 
      return
17635 
    iprot.readStructBegin()
17636 
    while True:
17637 
      (fname, ftype, fid) = iprot.readFieldBegin()
17638 
      if ftype == TType.STOP:
17639 
        break
17640 
      if fid == 0:
17641 
        if ftype == TType.BOOL:
17642 
          self.success = iprot.readBool();
17643 
        else:
17644 
          iprot.skip(ftype)
17645 
      else:
17646 
        iprot.skip(ftype)
17647 
      iprot.readFieldEnd()
17648 
    iprot.readStructEnd()
17649 
 
17650 
  def write(self, oprot):
17651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17653 
      return
17654 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17655 
    if self.success is not None:
17656 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17657 
      oprot.writeBool(self.success)
17658 
      oprot.writeFieldEnd()
17659 
    oprot.writeFieldStop()
17660 
    oprot.writeStructEnd()
17661 
 
17662 
  def validate(self):
17663 
    return
17664 
 
17665 
 
17666 
  def __repr__(self):
17667 
    L = ['%s=%r' % (key, value)
17668 
      for key, value in self.__dict__.iteritems()]
17669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17670 
 
17671 
  def __eq__(self, other):
17672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17673 
 
17674 
  def __ne__(self, other):
17675 
    return not (self == other)
18764 kshitij.so 17676 
 
19182 amit.gupta 17677 
class taxInvoiceAvailable_args:
17678 
  """
17679 
  Attributes:
17680 
   - addressId
17681 
  """
17682 
 
17683 
  thrift_spec = (
17684 
    None, # 0
17685 
    (1, TType.I64, 'addressId', None, None, ), # 1
17686 
  )
17687 
 
17688 
  def __init__(self, addressId=None,):
17689 
    self.addressId = addressId
17690 
 
17691 
  def read(self, iprot):
17692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17694 
      return
17695 
    iprot.readStructBegin()
17696 
    while True:
17697 
      (fname, ftype, fid) = iprot.readFieldBegin()
17698 
      if ftype == TType.STOP:
17699 
        break
17700 
      if fid == 1:
17701 
        if ftype == TType.I64:
17702 
          self.addressId = iprot.readI64();
17703 
        else:
17704 
          iprot.skip(ftype)
17705 
      else:
17706 
        iprot.skip(ftype)
17707 
      iprot.readFieldEnd()
17708 
    iprot.readStructEnd()
17709 
 
17710 
  def write(self, oprot):
17711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17713 
      return
17714 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
17715 
    if self.addressId is not None:
17716 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
17717 
      oprot.writeI64(self.addressId)
17718 
      oprot.writeFieldEnd()
17719 
    oprot.writeFieldStop()
17720 
    oprot.writeStructEnd()
17721 
 
17722 
  def validate(self):
17723 
    return
17724 
 
17725 
 
17726 
  def __repr__(self):
17727 
    L = ['%s=%r' % (key, value)
17728 
      for key, value in self.__dict__.iteritems()]
17729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17730 
 
17731 
  def __eq__(self, other):
17732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17733 
 
17734 
  def __ne__(self, other):
17735 
    return not (self == other)
17736 
 
17737 
class taxInvoiceAvailable_result:
17738 
  """
17739 
  Attributes:
17740 
   - success
17741 
  """
17742 
 
17743 
  thrift_spec = (
17744 
    (0, TType.BOOL, 'success', None, None, ), # 0
17745 
  )
17746 
 
17747 
  def __init__(self, success=None,):
17748 
    self.success = success
17749 
 
17750 
  def read(self, iprot):
17751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17753 
      return
17754 
    iprot.readStructBegin()
17755 
    while True:
17756 
      (fname, ftype, fid) = iprot.readFieldBegin()
17757 
      if ftype == TType.STOP:
17758 
        break
17759 
      if fid == 0:
17760 
        if ftype == TType.BOOL:
17761 
          self.success = iprot.readBool();
17762 
        else:
17763 
          iprot.skip(ftype)
17764 
      else:
17765 
        iprot.skip(ftype)
17766 
      iprot.readFieldEnd()
17767 
    iprot.readStructEnd()
17768 
 
17769 
  def write(self, oprot):
17770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17772 
      return
17773 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
17774 
    if self.success is not None:
17775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17776 
      oprot.writeBool(self.success)
17777 
      oprot.writeFieldEnd()
17778 
    oprot.writeFieldStop()
17779 
    oprot.writeStructEnd()
17780 
 
17781 
  def validate(self):
17782 
    return
17783 
 
17784 
 
17785 
  def __repr__(self):
17786 
    L = ['%s=%r' % (key, value)
17787 
      for key, value in self.__dict__.iteritems()]
17788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17789 
 
17790 
  def __eq__(self, other):
17791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17792 
 
17793 
  def __ne__(self, other):
17794 
    return not (self == other)
17795 
 
18764 kshitij.so 17796 
class getCartByValue_args:
17797 
  """
17798 
  Attributes:
17799 
   - cartIds
17800 
  """
17801 
 
17802 
  thrift_spec = (
17803 
    None, # 0
17804 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17805 
  )
17806 
 
17807 
  def __init__(self, cartIds=None,):
17808 
    self.cartIds = cartIds
17809 
 
17810 
  def read(self, iprot):
17811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17813 
      return
17814 
    iprot.readStructBegin()
17815 
    while True:
17816 
      (fname, ftype, fid) = iprot.readFieldBegin()
17817 
      if ftype == TType.STOP:
17818 
        break
17819 
      if fid == 1:
17820 
        if ftype == TType.LIST:
17821 
          self.cartIds = []
17822 
          (_etype258, _size255) = iprot.readListBegin()
17823 
          for _i259 in xrange(_size255):
17824 
            _elem260 = iprot.readI64();
17825 
            self.cartIds.append(_elem260)
17826 
          iprot.readListEnd()
17827 
        else:
17828 
          iprot.skip(ftype)
17829 
      else:
17830 
        iprot.skip(ftype)
17831 
      iprot.readFieldEnd()
17832 
    iprot.readStructEnd()
17833 
 
17834 
  def write(self, oprot):
17835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17837 
      return
17838 
    oprot.writeStructBegin('getCartByValue_args')
17839 
    if self.cartIds is not None:
17840 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17841 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17842 
      for iter261 in self.cartIds:
17843 
        oprot.writeI64(iter261)
17844 
      oprot.writeListEnd()
17845 
      oprot.writeFieldEnd()
17846 
    oprot.writeFieldStop()
17847 
    oprot.writeStructEnd()
17848 
 
17849 
  def validate(self):
17850 
    return
17851 
 
17852 
 
17853 
  def __repr__(self):
17854 
    L = ['%s=%r' % (key, value)
17855 
      for key, value in self.__dict__.iteritems()]
17856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17857 
 
17858 
  def __eq__(self, other):
17859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17860 
 
17861 
  def __ne__(self, other):
17862 
    return not (self == other)
17863 
 
17864 
class getCartByValue_result:
17865 
  """
17866 
  Attributes:
17867 
   - success
17868 
  """
17869 
 
17870 
  thrift_spec = (
17871 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17872 
  )
17873 
 
17874 
  def __init__(self, success=None,):
17875 
    self.success = success
17876 
 
17877 
  def read(self, iprot):
17878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17880 
      return
17881 
    iprot.readStructBegin()
17882 
    while True:
17883 
      (fname, ftype, fid) = iprot.readFieldBegin()
17884 
      if ftype == TType.STOP:
17885 
        break
17886 
      if fid == 0:
17887 
        if ftype == TType.MAP:
17888 
          self.success = {}
17889 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17890 
          for _i266 in xrange(_size262):
17891 
            _key267 = iprot.readI64();
17892 
            _val268 = []
17893 
            (_etype272, _size269) = iprot.readListBegin()
17894 
            for _i273 in xrange(_size269):
17895 
              _elem274 = Line()
17896 
              _elem274.read(iprot)
17897 
              _val268.append(_elem274)
17898 
            iprot.readListEnd()
17899 
            self.success[_key267] = _val268
17900 
          iprot.readMapEnd()
17901 
        else:
17902 
          iprot.skip(ftype)
17903 
      else:
17904 
        iprot.skip(ftype)
17905 
      iprot.readFieldEnd()
17906 
    iprot.readStructEnd()
17907 
 
17908 
  def write(self, oprot):
17909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17911 
      return
17912 
    oprot.writeStructBegin('getCartByValue_result')
17913 
    if self.success is not None:
17914 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17915 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17916 
      for kiter275,viter276 in self.success.items():
17917 
        oprot.writeI64(kiter275)
17918 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17919 
        for iter277 in viter276:
17920 
          iter277.write(oprot)
17921 
        oprot.writeListEnd()
17922 
      oprot.writeMapEnd()
17923 
      oprot.writeFieldEnd()
17924 
    oprot.writeFieldStop()
17925 
    oprot.writeStructEnd()
17926 
 
17927 
  def validate(self):
17928 
    return
17929 
 
17930 
 
17931 
  def __repr__(self):
17932 
    L = ['%s=%r' % (key, value)
17933 
      for key, value in self.__dict__.iteritems()]
17934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17935 
 
17936 
  def __eq__(self, other):
17937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17938 
 
17939 
  def __ne__(self, other):
17940 
    return not (self == other)
19889 manas 17941 
 
17942 
class getCounterName_args:
17943 
  """
17944 
  Attributes:
17945 
   - userIds
17946 
  """
17947 
 
17948 
  thrift_spec = (
17949 
    None, # 0
17950 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
17951 
  )
17952 
 
17953 
  def __init__(self, userIds=None,):
17954 
    self.userIds = userIds
17955 
 
17956 
  def read(self, iprot):
17957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17959 
      return
17960 
    iprot.readStructBegin()
17961 
    while True:
17962 
      (fname, ftype, fid) = iprot.readFieldBegin()
17963 
      if ftype == TType.STOP:
17964 
        break
17965 
      if fid == 1:
17966 
        if ftype == TType.LIST:
17967 
          self.userIds = []
17968 
          (_etype281, _size278) = iprot.readListBegin()
17969 
          for _i282 in xrange(_size278):
17970 
            _elem283 = iprot.readI64();
17971 
            self.userIds.append(_elem283)
17972 
          iprot.readListEnd()
17973 
        else:
17974 
          iprot.skip(ftype)
17975 
      else:
17976 
        iprot.skip(ftype)
17977 
      iprot.readFieldEnd()
17978 
    iprot.readStructEnd()
17979 
 
17980 
  def write(self, oprot):
17981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17983 
      return
17984 
    oprot.writeStructBegin('getCounterName_args')
17985 
    if self.userIds is not None:
17986 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
17987 
      oprot.writeListBegin(TType.I64, len(self.userIds))
17988 
      for iter284 in self.userIds:
17989 
        oprot.writeI64(iter284)
17990 
      oprot.writeListEnd()
17991 
      oprot.writeFieldEnd()
17992 
    oprot.writeFieldStop()
17993 
    oprot.writeStructEnd()
17994 
 
17995 
  def validate(self):
17996 
    return
17997 
 
17998 
 
17999 
  def __repr__(self):
18000 
    L = ['%s=%r' % (key, value)
18001 
      for key, value in self.__dict__.iteritems()]
18002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18003 
 
18004 
  def __eq__(self, other):
18005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18006 
 
18007 
  def __ne__(self, other):
18008 
    return not (self == other)
18009 
 
18010 
class getCounterName_result:
18011 
  """
18012 
  Attributes:
18013 
   - success
18014 
  """
18015 
 
18016 
  thrift_spec = (
18017 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18018 
  )
18019 
 
18020 
  def __init__(self, success=None,):
18021 
    self.success = success
18022 
 
18023 
  def read(self, iprot):
18024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18026 
      return
18027 
    iprot.readStructBegin()
18028 
    while True:
18029 
      (fname, ftype, fid) = iprot.readFieldBegin()
18030 
      if ftype == TType.STOP:
18031 
        break
18032 
      if fid == 0:
18033 
        if ftype == TType.MAP:
18034 
          self.success = {}
18035 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
18036 
          for _i289 in xrange(_size285):
18037 
            _key290 = iprot.readI64();
18038 
            _val291 = iprot.readString();
18039 
            self.success[_key290] = _val291
18040 
          iprot.readMapEnd()
18041 
        else:
18042 
          iprot.skip(ftype)
18043 
      else:
18044 
        iprot.skip(ftype)
18045 
      iprot.readFieldEnd()
18046 
    iprot.readStructEnd()
18047 
 
18048 
  def write(self, oprot):
18049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18051 
      return
18052 
    oprot.writeStructBegin('getCounterName_result')
18053 
    if self.success is not None:
18054 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18055 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
18056 
      for kiter292,viter293 in self.success.items():
18057 
        oprot.writeI64(kiter292)
18058 
        oprot.writeString(viter293)
18059 
      oprot.writeMapEnd()
18060 
      oprot.writeFieldEnd()
18061 
    oprot.writeFieldStop()
18062 
    oprot.writeStructEnd()
18063 
 
18064 
  def validate(self):
18065 
    return
18066 
 
18067 
 
18068 
  def __repr__(self):
18069 
    L = ['%s=%r' % (key, value)
18070 
      for key, value in self.__dict__.iteritems()]
18071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18072 
 
18073 
  def __eq__(self, other):
18074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18075 
 
18076 
  def __ne__(self, other):
18077 
    return not (self == other)
20873 kshitij.so 18078 
 
18079 
class setWalletAmountInCart_args:
18080 
  """
18081 
  Attributes:
18082 
   - cartId
18083 
   - wallet_amount
18084 
  """
18085 
 
18086 
  thrift_spec = (
18087 
    None, # 0
18088 
    (1, TType.I64, 'cartId', None, None, ), # 1
18089 
    (2, TType.DOUBLE, 'wallet_amount', None, None, ), # 2
18090 
  )
18091 
 
18092 
  def __init__(self, cartId=None, wallet_amount=None,):
18093 
    self.cartId = cartId
18094 
    self.wallet_amount = wallet_amount
18095 
 
18096 
  def read(self, iprot):
18097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18099 
      return
18100 
    iprot.readStructBegin()
18101 
    while True:
18102 
      (fname, ftype, fid) = iprot.readFieldBegin()
18103 
      if ftype == TType.STOP:
18104 
        break
18105 
      if fid == 1:
18106 
        if ftype == TType.I64:
18107 
          self.cartId = iprot.readI64();
18108 
        else:
18109 
          iprot.skip(ftype)
18110 
      elif fid == 2:
18111 
        if ftype == TType.DOUBLE:
18112 
          self.wallet_amount = iprot.readDouble();
18113 
        else:
18114 
          iprot.skip(ftype)
18115 
      else:
18116 
        iprot.skip(ftype)
18117 
      iprot.readFieldEnd()
18118 
    iprot.readStructEnd()
18119 
 
18120 
  def write(self, oprot):
18121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18123 
      return
18124 
    oprot.writeStructBegin('setWalletAmountInCart_args')
18125 
    if self.cartId is not None:
18126 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18127 
      oprot.writeI64(self.cartId)
18128 
      oprot.writeFieldEnd()
18129 
    if self.wallet_amount is not None:
18130 
      oprot.writeFieldBegin('wallet_amount', TType.DOUBLE, 2)
18131 
      oprot.writeDouble(self.wallet_amount)
18132 
      oprot.writeFieldEnd()
18133 
    oprot.writeFieldStop()
18134 
    oprot.writeStructEnd()
18135 
 
18136 
  def validate(self):
18137 
    return
18138 
 
18139 
 
18140 
  def __repr__(self):
18141 
    L = ['%s=%r' % (key, value)
18142 
      for key, value in self.__dict__.iteritems()]
18143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18144 
 
18145 
  def __eq__(self, other):
18146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18147 
 
18148 
  def __ne__(self, other):
18149 
    return not (self == other)
18150 
 
18151 
class setWalletAmountInCart_result:
18152 
  """
18153 
  Attributes:
18154 
   - success
18155 
  """
18156 
 
18157 
  thrift_spec = (
18158 
    (0, TType.BOOL, 'success', None, None, ), # 0
18159 
  )
18160 
 
18161 
  def __init__(self, success=None,):
18162 
    self.success = success
18163 
 
18164 
  def read(self, iprot):
18165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18167 
      return
18168 
    iprot.readStructBegin()
18169 
    while True:
18170 
      (fname, ftype, fid) = iprot.readFieldBegin()
18171 
      if ftype == TType.STOP:
18172 
        break
18173 
      if fid == 0:
18174 
        if ftype == TType.BOOL:
18175 
          self.success = iprot.readBool();
18176 
        else:
18177 
          iprot.skip(ftype)
18178 
      else:
18179 
        iprot.skip(ftype)
18180 
      iprot.readFieldEnd()
18181 
    iprot.readStructEnd()
18182 
 
18183 
  def write(self, oprot):
18184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18186 
      return
18187 
    oprot.writeStructBegin('setWalletAmountInCart_result')
18188 
    if self.success is not None:
18189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18190 
      oprot.writeBool(self.success)
18191 
      oprot.writeFieldEnd()
18192 
    oprot.writeFieldStop()
18193 
    oprot.writeStructEnd()
18194 
 
18195 
  def validate(self):
18196 
    return
18197 
 
18198 
 
18199 
  def __repr__(self):
18200 
    L = ['%s=%r' % (key, value)
18201 
      for key, value in self.__dict__.iteritems()]
18202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18203 
 
18204 
  def __eq__(self, other):
18205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18206 
 
18207 
  def __ne__(self, other):
18208 
    return not (self == other)