Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
18977 amit.gupta 713 
  def getCounterByUserId(self, userId):
714 
    """
715 
    Parameters:
716 
     - userId
717 
    """
718 
    pass
719 
 
12722 amit.gupta 720 
  def getAllUsersByCounter(self, counterId):
721 
    """
722 
    Parameters:
723 
     - counterId
724 
    """
725 
    pass
726 
 
15251 manish.sha 727 
  def getActiveAccessTokenForUser(self, userId, source):
728 
    """
729 
    Parameters:
730 
     - userId
731 
     - source
732 
    """
733 
    pass
12722 amit.gupta 734 
 
15251 manish.sha 735 
  def validateAccessToken(self, accessToken):
736 
    """
737 
    Parameters:
738 
     - accessToken
739 
    """
740 
    pass
741 
 
17782 amit.gupta 742 
  def addItemsToCart(self, cartId, itemQty, couponCode):
743 
    """
744 
    Parameters:
745 
     - cartId
746 
     - itemQty
747 
     - couponCode
748 
    """
749 
    pass
15251 manish.sha 750 
 
17782 amit.gupta 751 
  def validateCartNew(self, cartId, pinCode, sourceId):
752 
    """
753 
    Parameters:
754 
     - cartId
755 
     - pinCode
756 
     - sourceId
757 
    """
758 
    pass
759 
 
18644 manish.sha 760 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
765 
    pass
17782 amit.gupta 766 
 
18530 manish.sha 767 
  def getBillingAddressForUser(self, userId):
768 
    """
769 
    Parameters:
770 
     - userId
771 
    """
772 
    pass
773 
 
18590 manish.sha 774 
  def isCreditorAssigned(self, userId):
775 
    """
776 
    Parameters:
777 
     - userId
778 
    """
779 
    pass
18530 manish.sha 780 
 
18735 manish.sha 781 
  def isTaxInvoiceEnabledUser(self, userId):
782 
    """
783 
    Parameters:
784 
     - userId
785 
    """
786 
    pass
18590 manish.sha 787 
 
19182 amit.gupta 788 
  def taxInvoiceAvailable(self, addressId):
789 
    """
790 
    Parameters:
791 
     - addressId
792 
    """
793 
    pass
794 
 
18764 kshitij.so 795 
  def getCartByValue(self, cartIds):
796 
    """
797 
    Parameters:
798 
     - cartIds
799 
    """
800 
    pass
18735 manish.sha 801 
 
19889 manas 802 
  def getCounterName(self, userIds):
803 
    """
804 
    Parameters:
805 
     - userIds
806 
    """
807 
    pass
18764 kshitij.so 808 
 
20873 kshitij.so 809 
  def setWalletAmountInCart(self, cartId, wallet_amount):
810 
    """
811 
    Parameters:
812 
     - cartId
813 
     - wallet_amount
814 
    """
815 
    pass
19889 manas 816 
 
20873 kshitij.so 817 
 
3376 rajveer 818 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 819 
  """
820 
  service
821 
  """
822 
  def __init__(self, iprot, oprot=None):
3376 rajveer 823 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 824 
 
559 chandransh 825 
  def createAnonymousUser(self, jsessionId):
94 ashish 826 
    """
827 
    Parameters:
559 chandransh 828 
     - jsessionId
94 ashish 829 
    """
559 chandransh 830 
    self.send_createAnonymousUser(jsessionId)
831 
    return self.recv_createAnonymousUser()
94 ashish 832 
 
559 chandransh 833 
  def send_createAnonymousUser(self, jsessionId):
834 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
835 
    args = createAnonymousUser_args()
836 
    args.jsessionId = jsessionId
94 ashish 837 
    args.write(self._oprot)
838 
    self._oprot.writeMessageEnd()
839 
    self._oprot.trans.flush()
840 
 
559 chandransh 841 
  def recv_createAnonymousUser(self, ):
94 ashish 842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
843 
    if mtype == TMessageType.EXCEPTION:
844 
      x = TApplicationException()
845 
      x.read(self._iprot)
846 
      self._iprot.readMessageEnd()
847 
      raise x
559 chandransh 848 
    result = createAnonymousUser_result()
94 ashish 849 
    result.read(self._iprot)
850 
    self._iprot.readMessageEnd()
3431 rajveer 851 
    if result.success is not None:
94 ashish 852 
      return result.success
3431 rajveer 853 
    if result.ucex is not None:
559 chandransh 854 
      raise result.ucex
855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 856 
 
559 chandransh 857 
  def getUserById(self, userId):
94 ashish 858 
    """
859 
    Parameters:
860 
     - userId
861 
    """
559 chandransh 862 
    self.send_getUserById(userId)
863 
    return self.recv_getUserById()
94 ashish 864 
 
559 chandransh 865 
  def send_getUserById(self, userId):
866 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
867 
    args = getUserById_args()
94 ashish 868 
    args.userId = userId
869 
    args.write(self._oprot)
870 
    self._oprot.writeMessageEnd()
871 
    self._oprot.trans.flush()
872 
 
559 chandransh 873 
  def recv_getUserById(self, ):
94 ashish 874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
875 
    if mtype == TMessageType.EXCEPTION:
876 
      x = TApplicationException()
877 
      x.read(self._iprot)
878 
      self._iprot.readMessageEnd()
879 
      raise x
559 chandransh 880 
    result = getUserById_result()
94 ashish 881 
    result.read(self._iprot)
882 
    self._iprot.readMessageEnd()
3431 rajveer 883 
    if result.success is not None:
94 ashish 884 
      return result.success
3431 rajveer 885 
    if result.ucex is not None:
559 chandransh 886 
      raise result.ucex
887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 888 
 
5326 rajveer 889 
  def getUserByCartId(self, cartId):
890 
    """
891 
    Parameters:
892 
     - cartId
893 
    """
894 
    self.send_getUserByCartId(cartId)
895 
    return self.recv_getUserByCartId()
896 
 
897 
  def send_getUserByCartId(self, cartId):
898 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
899 
    args = getUserByCartId_args()
900 
    args.cartId = cartId
901 
    args.write(self._oprot)
902 
    self._oprot.writeMessageEnd()
903 
    self._oprot.trans.flush()
904 
 
905 
  def recv_getUserByCartId(self, ):
906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
907 
    if mtype == TMessageType.EXCEPTION:
908 
      x = TApplicationException()
909 
      x.read(self._iprot)
910 
      self._iprot.readMessageEnd()
911 
      raise x
912 
    result = getUserByCartId_result()
913 
    result.read(self._iprot)
914 
    self._iprot.readMessageEnd()
915 
    if result.success is not None:
916 
      return result.success
917 
    if result.ucex is not None:
918 
      raise result.ucex
919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
920 
 
1491 vikas 921 
  def getUserByEmail(self, email):
922 
    """
923 
    Parameters:
924 
     - email
925 
    """
926 
    self.send_getUserByEmail(email)
927 
    return self.recv_getUserByEmail()
928 
 
929 
  def send_getUserByEmail(self, email):
930 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
931 
    args = getUserByEmail_args()
932 
    args.email = email
933 
    args.write(self._oprot)
934 
    self._oprot.writeMessageEnd()
935 
    self._oprot.trans.flush()
936 
 
937 
  def recv_getUserByEmail(self, ):
938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
939 
    if mtype == TMessageType.EXCEPTION:
940 
      x = TApplicationException()
941 
      x.read(self._iprot)
942 
      self._iprot.readMessageEnd()
943 
      raise x
944 
    result = getUserByEmail_result()
945 
    result.read(self._iprot)
946 
    self._iprot.readMessageEnd()
3431 rajveer 947 
    if result.success is not None:
1491 vikas 948 
      return result.success
3431 rajveer 949 
    if result.ucex is not None:
1491 vikas 950 
      raise result.ucex
951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
952 
 
3032 mandeep.dh 953 
  def getUserByMobileNumber(self, mobileNumber):
954 
    """
955 
    Parameters:
956 
     - mobileNumber
957 
    """
958 
    self.send_getUserByMobileNumber(mobileNumber)
959 
    return self.recv_getUserByMobileNumber()
960 
 
961 
  def send_getUserByMobileNumber(self, mobileNumber):
962 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
963 
    args = getUserByMobileNumber_args()
964 
    args.mobileNumber = mobileNumber
965 
    args.write(self._oprot)
966 
    self._oprot.writeMessageEnd()
967 
    self._oprot.trans.flush()
968 
 
969 
  def recv_getUserByMobileNumber(self, ):
970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
971 
    if mtype == TMessageType.EXCEPTION:
972 
      x = TApplicationException()
973 
      x.read(self._iprot)
974 
      self._iprot.readMessageEnd()
975 
      raise x
976 
    result = getUserByMobileNumber_result()
977 
    result.read(self._iprot)
978 
    self._iprot.readMessageEnd()
3431 rajveer 979 
    if result.success is not None:
3032 mandeep.dh 980 
      return result.success
3431 rajveer 981 
    if result.ucex is not None:
3032 mandeep.dh 982 
      raise result.ucex
983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
984 
 
559 chandransh 985 
  def createUser(self, user):
94 ashish 986 
    """
987 
    Parameters:
559 chandransh 988 
     - user
94 ashish 989 
    """
559 chandransh 990 
    self.send_createUser(user)
991 
    return self.recv_createUser()
94 ashish 992 
 
559 chandransh 993 
  def send_createUser(self, user):
994 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
995 
    args = createUser_args()
996 
    args.user = user
94 ashish 997 
    args.write(self._oprot)
998 
    self._oprot.writeMessageEnd()
999 
    self._oprot.trans.flush()
1000 
 
559 chandransh 1001 
  def recv_createUser(self, ):
94 ashish 1002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1003 
    if mtype == TMessageType.EXCEPTION:
1004 
      x = TApplicationException()
1005 
      x.read(self._iprot)
1006 
      self._iprot.readMessageEnd()
1007 
      raise x
559 chandransh 1008 
    result = createUser_result()
94 ashish 1009 
    result.read(self._iprot)
1010 
    self._iprot.readMessageEnd()
3431 rajveer 1011 
    if result.success is not None:
94 ashish 1012 
      return result.success
3431 rajveer 1013 
    if result.ucex is not None:
559 chandransh 1014 
      raise result.ucex
1015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1016 
 
559 chandransh 1017 
  def updateUser(self, user):
94 ashish 1018 
    """
1019 
    Parameters:
559 chandransh 1020 
     - user
94 ashish 1021 
    """
559 chandransh 1022 
    self.send_updateUser(user)
1023 
    return self.recv_updateUser()
94 ashish 1024 
 
559 chandransh 1025 
  def send_updateUser(self, user):
1026 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1027 
    args = updateUser_args()
1028 
    args.user = user
94 ashish 1029 
    args.write(self._oprot)
1030 
    self._oprot.writeMessageEnd()
1031 
    self._oprot.trans.flush()
1032 
 
559 chandransh 1033 
  def recv_updateUser(self, ):
94 ashish 1034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1035 
    if mtype == TMessageType.EXCEPTION:
1036 
      x = TApplicationException()
1037 
      x.read(self._iprot)
1038 
      self._iprot.readMessageEnd()
1039 
      raise x
559 chandransh 1040 
    result = updateUser_result()
94 ashish 1041 
    result.read(self._iprot)
1042 
    self._iprot.readMessageEnd()
3431 rajveer 1043 
    if result.success is not None:
94 ashish 1044 
      return result.success
3431 rajveer 1045 
    if result.ucex is not None:
559 chandransh 1046 
      raise result.ucex
1047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1048 
 
559 chandransh 1049 
  def authenticateUser(self, email, password):
94 ashish 1050 
    """
1051 
    Parameters:
1052 
     - email
1053 
     - password
1054 
    """
559 chandransh 1055 
    self.send_authenticateUser(email, password)
122 ashish 1056 
    return self.recv_authenticateUser()
1057 
 
559 chandransh 1058 
  def send_authenticateUser(self, email, password):
122 ashish 1059 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1060 
    args = authenticateUser_args()
559 chandransh 1061 
    args.email = email
122 ashish 1062 
    args.password = password
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_authenticateUser(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = authenticateUser_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
3431 rajveer 1077 
    if result.success is not None:
122 ashish 1078 
      return result.success
3431 rajveer 1079 
    if result.auex is not None:
559 chandransh 1080 
      raise result.auex
122 ashish 1081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1082 
 
94 ashish 1083 
  def userExists(self, email):
1084 
    """
1085 
    Parameters:
1086 
     - email
1087 
    """
1088 
    self.send_userExists(email)
1089 
    return self.recv_userExists()
1090 
 
1091 
  def send_userExists(self, email):
1092 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1093 
    args = userExists_args()
1094 
    args.email = email
1095 
    args.write(self._oprot)
1096 
    self._oprot.writeMessageEnd()
1097 
    self._oprot.trans.flush()
1098 
 
1099 
  def recv_userExists(self, ):
1100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1101 
    if mtype == TMessageType.EXCEPTION:
1102 
      x = TApplicationException()
1103 
      x.read(self._iprot)
1104 
      self._iprot.readMessageEnd()
1105 
      raise x
1106 
    result = userExists_result()
1107 
    result.read(self._iprot)
1108 
    self._iprot.readMessageEnd()
3431 rajveer 1109 
    if result.success is not None:
94 ashish 1110 
      return result.success
3431 rajveer 1111 
    if result.ucx is not None:
94 ashish 1112 
      raise result.ucx
1113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1114 
 
567 rajveer 1115 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1116 
    """
1117 
    Parameters:
1118 
     - userId
1119 
     - address
513 rajveer 1120 
     - setDefault
94 ashish 1121 
    """
567 rajveer 1122 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1123 
    return self.recv_addAddressForUser()
1124 
 
567 rajveer 1125 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1126 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1127 
    args = addAddressForUser_args()
559 chandransh 1128 
    args.userId = userId
94 ashish 1129 
    args.address = address
513 rajveer 1130 
    args.setDefault = setDefault
94 ashish 1131 
    args.write(self._oprot)
1132 
    self._oprot.writeMessageEnd()
1133 
    self._oprot.trans.flush()
1134 
 
1135 
  def recv_addAddressForUser(self, ):
1136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1137 
    if mtype == TMessageType.EXCEPTION:
1138 
      x = TApplicationException()
1139 
      x.read(self._iprot)
1140 
      self._iprot.readMessageEnd()
1141 
      raise x
1142 
    result = addAddressForUser_result()
1143 
    result.read(self._iprot)
1144 
    self._iprot.readMessageEnd()
3431 rajveer 1145 
    if result.success is not None:
94 ashish 1146 
      return result.success
3431 rajveer 1147 
    if result.ucx is not None:
94 ashish 1148 
      raise result.ucx
1149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1150 
 
1151 
  def removeAddressForUser(self, userid, addressId):
1152 
    """
1153 
    Parameters:
1154 
     - userid
1155 
     - addressId
1156 
    """
1157 
    self.send_removeAddressForUser(userid, addressId)
1158 
    return self.recv_removeAddressForUser()
1159 
 
1160 
  def send_removeAddressForUser(self, userid, addressId):
1161 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1162 
    args = removeAddressForUser_args()
1163 
    args.userid = userid
1164 
    args.addressId = addressId
1165 
    args.write(self._oprot)
1166 
    self._oprot.writeMessageEnd()
1167 
    self._oprot.trans.flush()
1168 
 
1169 
  def recv_removeAddressForUser(self, ):
1170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1171 
    if mtype == TMessageType.EXCEPTION:
1172 
      x = TApplicationException()
1173 
      x.read(self._iprot)
1174 
      self._iprot.readMessageEnd()
1175 
      raise x
1176 
    result = removeAddressForUser_result()
1177 
    result.read(self._iprot)
1178 
    self._iprot.readMessageEnd()
3431 rajveer 1179 
    if result.success is not None:
94 ashish 1180 
      return result.success
3431 rajveer 1181 
    if result.ucx is not None:
94 ashish 1182 
      raise result.ucx
1183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1184 
 
1185 
  def setUserAsLoggedIn(self, userId, timestamp):
1186 
    """
1187 
    Parameters:
1188 
     - userId
1189 
     - timestamp
1190 
    """
1191 
    self.send_setUserAsLoggedIn(userId, timestamp)
1192 
    return self.recv_setUserAsLoggedIn()
1193 
 
1194 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1195 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1196 
    args = setUserAsLoggedIn_args()
1197 
    args.userId = userId
1198 
    args.timestamp = timestamp
1199 
    args.write(self._oprot)
1200 
    self._oprot.writeMessageEnd()
1201 
    self._oprot.trans.flush()
1202 
 
1203 
  def recv_setUserAsLoggedIn(self, ):
1204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1205 
    if mtype == TMessageType.EXCEPTION:
1206 
      x = TApplicationException()
1207 
      x.read(self._iprot)
1208 
      self._iprot.readMessageEnd()
1209 
      raise x
1210 
    result = setUserAsLoggedIn_result()
1211 
    result.read(self._iprot)
1212 
    self._iprot.readMessageEnd()
3431 rajveer 1213 
    if result.success is not None:
94 ashish 1214 
      return result.success
3431 rajveer 1215 
    if result.ucx is not None:
94 ashish 1216 
      raise result.ucx
1217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1218 
 
1219 
  def setUserAsLoggedOut(self, userid, timestamp):
1220 
    """
1221 
    Parameters:
1222 
     - userid
1223 
     - timestamp
1224 
    """
1225 
    self.send_setUserAsLoggedOut(userid, timestamp)
1226 
    return self.recv_setUserAsLoggedOut()
1227 
 
1228 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1229 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1230 
    args = setUserAsLoggedOut_args()
1231 
    args.userid = userid
1232 
    args.timestamp = timestamp
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1237 
  def recv_setUserAsLoggedOut(self, ):
1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1244 
    result = setUserAsLoggedOut_result()
1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
3431 rajveer 1247 
    if result.success is not None:
94 ashish 1248 
      return result.success
3431 rajveer 1249 
    if result.ucx is not None:
94 ashish 1250 
      raise result.ucx
1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1252 
 
504 rajveer 1253 
  def setDefaultAddress(self, userid, addressId):
1254 
    """
1255 
    Parameters:
1256 
     - userid
1257 
     - addressId
1258 
    """
1259 
    self.send_setDefaultAddress(userid, addressId)
1260 
    return self.recv_setDefaultAddress()
1261 
 
1262 
  def send_setDefaultAddress(self, userid, addressId):
1263 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1264 
    args = setDefaultAddress_args()
1265 
    args.userid = userid
1266 
    args.addressId = addressId
1267 
    args.write(self._oprot)
1268 
    self._oprot.writeMessageEnd()
1269 
    self._oprot.trans.flush()
1270 
 
1271 
  def recv_setDefaultAddress(self, ):
1272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1273 
    if mtype == TMessageType.EXCEPTION:
1274 
      x = TApplicationException()
1275 
      x.read(self._iprot)
1276 
      self._iprot.readMessageEnd()
1277 
      raise x
1278 
    result = setDefaultAddress_result()
1279 
    result.read(self._iprot)
1280 
    self._iprot.readMessageEnd()
3431 rajveer 1281 
    if result.success is not None:
504 rajveer 1282 
      return result.success
3431 rajveer 1283 
    if result.ucx is not None:
504 rajveer 1284 
      raise result.ucx
1285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1286 
 
594 rajveer 1287 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1288 
    """
1289 
    Parameters:
1290 
     - userid
594 rajveer 1291 
     - oldPassword
1292 
     - newPassword
94 ashish 1293 
    """
594 rajveer 1294 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1295 
    return self.recv_updatePassword()
1296 
 
594 rajveer 1297 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1298 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1299 
    args = updatePassword_args()
1300 
    args.userid = userid
594 rajveer 1301 
    args.oldPassword = oldPassword
1302 
    args.newPassword = newPassword
94 ashish 1303 
    args.write(self._oprot)
1304 
    self._oprot.writeMessageEnd()
1305 
    self._oprot.trans.flush()
1306 
 
1307 
  def recv_updatePassword(self, ):
1308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1309 
    if mtype == TMessageType.EXCEPTION:
1310 
      x = TApplicationException()
1311 
      x.read(self._iprot)
1312 
      self._iprot.readMessageEnd()
1313 
      raise x
1314 
    result = updatePassword_result()
1315 
    result.read(self._iprot)
1316 
    self._iprot.readMessageEnd()
3431 rajveer 1317 
    if result.success is not None:
94 ashish 1318 
      return result.success
3431 rajveer 1319 
    if result.ucx is not None:
94 ashish 1320 
      raise result.ucx
1321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1322 
 
884 rajveer 1323 
  def forgotPassword(self, email, newPassword):
581 rajveer 1324 
    """
1325 
    Parameters:
1326 
     - email
884 rajveer 1327 
     - newPassword
581 rajveer 1328 
    """
884 rajveer 1329 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1330 
    return self.recv_forgotPassword()
1331 
 
884 rajveer 1332 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1333 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1334 
    args = forgotPassword_args()
1335 
    args.email = email
884 rajveer 1336 
    args.newPassword = newPassword
581 rajveer 1337 
    args.write(self._oprot)
1338 
    self._oprot.writeMessageEnd()
1339 
    self._oprot.trans.flush()
1340 
 
1341 
  def recv_forgotPassword(self, ):
1342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1343 
    if mtype == TMessageType.EXCEPTION:
1344 
      x = TApplicationException()
1345 
      x.read(self._iprot)
1346 
      self._iprot.readMessageEnd()
1347 
      raise x
1348 
    result = forgotPassword_result()
1349 
    result.read(self._iprot)
1350 
    self._iprot.readMessageEnd()
3431 rajveer 1351 
    if result.success is not None:
581 rajveer 1352 
      return result.success
3431 rajveer 1353 
    if result.ucx is not None:
581 rajveer 1354 
      raise result.ucx
1355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1356 
 
594 rajveer 1357 
  def getAllAddressesForUser(self, userId):
1358 
    """
1359 
    Parameters:
1360 
     - userId
1361 
    """
1362 
    self.send_getAllAddressesForUser(userId)
1363 
    return self.recv_getAllAddressesForUser()
1364 
 
1365 
  def send_getAllAddressesForUser(self, userId):
1366 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1367 
    args = getAllAddressesForUser_args()
1368 
    args.userId = userId
1369 
    args.write(self._oprot)
1370 
    self._oprot.writeMessageEnd()
1371 
    self._oprot.trans.flush()
1372 
 
1373 
  def recv_getAllAddressesForUser(self, ):
1374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1375 
    if mtype == TMessageType.EXCEPTION:
1376 
      x = TApplicationException()
1377 
      x.read(self._iprot)
1378 
      self._iprot.readMessageEnd()
1379 
      raise x
1380 
    result = getAllAddressesForUser_result()
1381 
    result.read(self._iprot)
1382 
    self._iprot.readMessageEnd()
3431 rajveer 1383 
    if result.success is not None:
594 rajveer 1384 
      return result.success
3431 rajveer 1385 
    if result.ucx is not None:
594 rajveer 1386 
      raise result.ucx
1387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1388 
 
1894 vikas 1389 
  def getAddressById(self, addressId):
1390 
    """
1391 
    Parameters:
1392 
     - addressId
1393 
    """
1394 
    self.send_getAddressById(addressId)
1395 
    return self.recv_getAddressById()
1396 
 
1397 
  def send_getAddressById(self, addressId):
1398 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1399 
    args = getAddressById_args()
1400 
    args.addressId = addressId
1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
1405 
  def recv_getAddressById(self, ):
1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
1412 
    result = getAddressById_result()
1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
3431 rajveer 1415 
    if result.success is not None:
1894 vikas 1416 
      return result.success
3431 rajveer 1417 
    if result.ucx is not None:
1894 vikas 1418 
      raise result.ucx
1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1420 
 
594 rajveer 1421 
  def getDefaultAddressId(self, userId):
1422 
    """
1423 
    Parameters:
1424 
     - userId
1425 
    """
1426 
    self.send_getDefaultAddressId(userId)
1427 
    return self.recv_getDefaultAddressId()
1428 
 
1429 
  def send_getDefaultAddressId(self, userId):
1430 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1431 
    args = getDefaultAddressId_args()
1432 
    args.userId = userId
1433 
    args.write(self._oprot)
1434 
    self._oprot.writeMessageEnd()
1435 
    self._oprot.trans.flush()
1436 
 
1437 
  def recv_getDefaultAddressId(self, ):
1438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1439 
    if mtype == TMessageType.EXCEPTION:
1440 
      x = TApplicationException()
1441 
      x.read(self._iprot)
1442 
      self._iprot.readMessageEnd()
1443 
      raise x
1444 
    result = getDefaultAddressId_result()
1445 
    result.read(self._iprot)
1446 
    self._iprot.readMessageEnd()
3431 rajveer 1447 
    if result.success is not None:
594 rajveer 1448 
      return result.success
3431 rajveer 1449 
    if result.ucx is not None:
594 rajveer 1450 
      raise result.ucx
1451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1452 
 
785 rajveer 1453 
  def getDefaultPincode(self, userId):
1454 
    """
1455 
    Parameters:
1456 
     - userId
1457 
    """
1458 
    self.send_getDefaultPincode(userId)
1459 
    return self.recv_getDefaultPincode()
1460 
 
1461 
  def send_getDefaultPincode(self, userId):
1462 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1463 
    args = getDefaultPincode_args()
1464 
    args.userId = userId
1465 
    args.write(self._oprot)
1466 
    self._oprot.writeMessageEnd()
1467 
    self._oprot.trans.flush()
1468 
 
1469 
  def recv_getDefaultPincode(self, ):
1470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1471 
    if mtype == TMessageType.EXCEPTION:
1472 
      x = TApplicationException()
1473 
      x.read(self._iprot)
1474 
      self._iprot.readMessageEnd()
1475 
      raise x
1476 
    result = getDefaultPincode_result()
1477 
    result.read(self._iprot)
1478 
    self._iprot.readMessageEnd()
3431 rajveer 1479 
    if result.success is not None:
785 rajveer 1480 
      return result.success
3431 rajveer 1481 
    if result.ucx is not None:
785 rajveer 1482 
      raise result.ucx
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1484 
 
1274 varun.gupt 1485 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1486 
    """
1487 
    Parameters:
1488 
     - userId
1489 
     - replyTo
1490 
     - communicationType
1491 
     - orderId
1492 
     - airwaybillNo
1493 
     - productName
1494 
     - subject
1495 
     - message
1496 
    """
1497 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1498 
    return self.recv_saveUserCommunication()
1499 
 
1500 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1501 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1502 
    args = saveUserCommunication_args()
1503 
    args.userId = userId
1504 
    args.replyTo = replyTo
1505 
    args.communicationType = communicationType
1506 
    args.orderId = orderId
1507 
    args.airwaybillNo = airwaybillNo
1508 
    args.productName = productName
1509 
    args.subject = subject
1510 
    args.message = message
1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
1515 
  def recv_saveUserCommunication(self, ):
1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
1522 
    result = saveUserCommunication_result()
1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
3431 rajveer 1525 
    if result.success is not None:
1274 varun.gupt 1526 
      return result.success
3431 rajveer 1527 
    if result.ucx is not None:
1274 varun.gupt 1528 
      raise result.ucx
1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1530 
 
1590 varun.gupt 1531 
  def getUserCommunicationById(self, id):
1532 
    """
1533 
    Parameters:
1534 
     - id
1535 
    """
1536 
    self.send_getUserCommunicationById(id)
1537 
    return self.recv_getUserCommunicationById()
1538 
 
1539 
  def send_getUserCommunicationById(self, id):
1540 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1541 
    args = getUserCommunicationById_args()
1542 
    args.id = id
1543 
    args.write(self._oprot)
1544 
    self._oprot.writeMessageEnd()
1545 
    self._oprot.trans.flush()
1546 
 
1547 
  def recv_getUserCommunicationById(self, ):
1548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1549 
    if mtype == TMessageType.EXCEPTION:
1550 
      x = TApplicationException()
1551 
      x.read(self._iprot)
1552 
      self._iprot.readMessageEnd()
1553 
      raise x
1554 
    result = getUserCommunicationById_result()
1555 
    result.read(self._iprot)
1556 
    self._iprot.readMessageEnd()
3431 rajveer 1557 
    if result.success is not None:
1590 varun.gupt 1558 
      return result.success
3431 rajveer 1559 
    if result.ucx is not None:
1590 varun.gupt 1560 
      raise result.ucx
1561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1562 
 
1563 
  def getUserCommunicationByUser(self, userId):
1564 
    """
1565 
    Parameters:
1566 
     - userId
1567 
    """
1568 
    self.send_getUserCommunicationByUser(userId)
1569 
    return self.recv_getUserCommunicationByUser()
1570 
 
1571 
  def send_getUserCommunicationByUser(self, userId):
1572 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1573 
    args = getUserCommunicationByUser_args()
1574 
    args.userId = userId
1575 
    args.write(self._oprot)
1576 
    self._oprot.writeMessageEnd()
1577 
    self._oprot.trans.flush()
1578 
 
1579 
  def recv_getUserCommunicationByUser(self, ):
1580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1581 
    if mtype == TMessageType.EXCEPTION:
1582 
      x = TApplicationException()
1583 
      x.read(self._iprot)
1584 
      self._iprot.readMessageEnd()
1585 
      raise x
1586 
    result = getUserCommunicationByUser_result()
1587 
    result.read(self._iprot)
1588 
    self._iprot.readMessageEnd()
3431 rajveer 1589 
    if result.success is not None:
1590 varun.gupt 1590 
      return result.success
3431 rajveer 1591 
    if result.ucx is not None:
1590 varun.gupt 1592 
      raise result.ucx
1593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1594 
 
1595 
  def getAllUserCommunications(self, ):
1596 
    self.send_getAllUserCommunications()
1597 
    return self.recv_getAllUserCommunications()
1598 
 
1599 
  def send_getAllUserCommunications(self, ):
1600 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1601 
    args = getAllUserCommunications_args()
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getAllUserCommunications(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getAllUserCommunications_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
1590 varun.gupt 1617 
      return result.success
3431 rajveer 1618 
    if result.ucx is not None:
1590 varun.gupt 1619 
      raise result.ucx
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1621 
 
5407 amar.kumar 1622 
  def removeUserCommunication(self, id):
1623 
    """
1624 
    Parameters:
1625 
     - id
1626 
    """
1627 
    self.send_removeUserCommunication(id)
1628 
    self.recv_removeUserCommunication()
1629 
 
1630 
  def send_removeUserCommunication(self, id):
1631 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1632 
    args = removeUserCommunication_args()
1633 
    args.id = id
1634 
    args.write(self._oprot)
1635 
    self._oprot.writeMessageEnd()
1636 
    self._oprot.trans.flush()
1637 
 
1638 
  def recv_removeUserCommunication(self, ):
1639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1640 
    if mtype == TMessageType.EXCEPTION:
1641 
      x = TApplicationException()
1642 
      x.read(self._iprot)
1643 
      self._iprot.readMessageEnd()
1644 
      raise x
1645 
    result = removeUserCommunication_result()
1646 
    result.read(self._iprot)
1647 
    self._iprot.readMessageEnd()
1648 
    if result.ucx is not None:
1649 
      raise result.ucx
1650 
    return
1651 
 
1859 vikas 1652 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1653 
    """
1654 
    Parameters:
1655 
     - name
1859 vikas 1656 
     - addedOn
1845 vikas 1657 
    """
1859 vikas 1658 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1659 
    return self.recv_createMasterAffiliate()
1660 
 
1859 vikas 1661 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1662 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1663 
    args = createMasterAffiliate_args()
1664 
    args.name = name
1859 vikas 1665 
    args.addedOn = addedOn
1845 vikas 1666 
    args.write(self._oprot)
1667 
    self._oprot.writeMessageEnd()
1668 
    self._oprot.trans.flush()
1669 
 
1670 
  def recv_createMasterAffiliate(self, ):
1671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1672 
    if mtype == TMessageType.EXCEPTION:
1673 
      x = TApplicationException()
1674 
      x.read(self._iprot)
1675 
      self._iprot.readMessageEnd()
1676 
      raise x
1677 
    result = createMasterAffiliate_result()
1678 
    result.read(self._iprot)
1679 
    self._iprot.readMessageEnd()
3431 rajveer 1680 
    if result.success is not None:
1845 vikas 1681 
      return result.success
3431 rajveer 1682 
    if result.utx is not None:
1845 vikas 1683 
      raise result.utx
1684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1685 
 
1899 vikas 1686 
  def getAllMasterAffiliates(self, ):
1687 
    self.send_getAllMasterAffiliates()
1688 
    return self.recv_getAllMasterAffiliates()
1689 
 
1690 
  def send_getAllMasterAffiliates(self, ):
1691 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1692 
    args = getAllMasterAffiliates_args()
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getAllMasterAffiliates(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getAllMasterAffiliates_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
3431 rajveer 1707 
    if result.success is not None:
1899 vikas 1708 
      return result.success
3431 rajveer 1709 
    if result.utx is not None:
1899 vikas 1710 
      raise result.utx
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1712 
 
1845 vikas 1713 
  def getMasterAffiliateById(self, id):
1714 
    """
1715 
    Parameters:
1716 
     - id
1717 
    """
1718 
    self.send_getMasterAffiliateById(id)
1719 
    return self.recv_getMasterAffiliateById()
1720 
 
1721 
  def send_getMasterAffiliateById(self, id):
1722 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1723 
    args = getMasterAffiliateById_args()
1724 
    args.id = id
1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
1729 
  def recv_getMasterAffiliateById(self, ):
1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
1736 
    result = getMasterAffiliateById_result()
1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
3431 rajveer 1739 
    if result.success is not None:
1845 vikas 1740 
      return result.success
3431 rajveer 1741 
    if result.utx is not None:
1845 vikas 1742 
      raise result.utx
1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1744 
 
1745 
  def getMasterAffiliateByName(self, name):
1746 
    """
1747 
    Parameters:
1748 
     - name
1749 
    """
1750 
    self.send_getMasterAffiliateByName(name)
1751 
    return self.recv_getMasterAffiliateByName()
1752 
 
1753 
  def send_getMasterAffiliateByName(self, name):
1754 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1755 
    args = getMasterAffiliateByName_args()
1756 
    args.name = name
1757 
    args.write(self._oprot)
1758 
    self._oprot.writeMessageEnd()
1759 
    self._oprot.trans.flush()
1760 
 
1761 
  def recv_getMasterAffiliateByName(self, ):
1762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1763 
    if mtype == TMessageType.EXCEPTION:
1764 
      x = TApplicationException()
1765 
      x.read(self._iprot)
1766 
      self._iprot.readMessageEnd()
1767 
      raise x
1768 
    result = getMasterAffiliateByName_result()
1769 
    result.read(self._iprot)
1770 
    self._iprot.readMessageEnd()
3431 rajveer 1771 
    if result.success is not None:
1845 vikas 1772 
      return result.success
3431 rajveer 1773 
    if result.utx is not None:
1845 vikas 1774 
      raise result.utx
1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1776 
 
1859 vikas 1777 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1778 
    """
1779 
    Parameters:
1780 
     - name
1781 
     - url
1782 
     - masterAffiliateId
1859 vikas 1783 
     - addedOn
1845 vikas 1784 
    """
1859 vikas 1785 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1786 
    return self.recv_createAffiliate()
1787 
 
1859 vikas 1788 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1789 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1790 
    args = createAffiliate_args()
1791 
    args.name = name
1792 
    args.url = url
1793 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1794 
    args.addedOn = addedOn
1845 vikas 1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_createAffiliate(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = createAffiliate_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
3431 rajveer 1809 
    if result.success is not None:
1845 vikas 1810 
      return result.success
3431 rajveer 1811 
    if result.utx is not None:
1845 vikas 1812 
      raise result.utx
1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1814 
 
1815 
  def getAffiliateById(self, id):
1816 
    """
1817 
    Parameters:
1818 
     - id
1819 
    """
1820 
    self.send_getAffiliateById(id)
1821 
    return self.recv_getAffiliateById()
1822 
 
1823 
  def send_getAffiliateById(self, id):
1824 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1825 
    args = getAffiliateById_args()
1826 
    args.id = id
1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
1831 
  def recv_getAffiliateById(self, ):
1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
1838 
    result = getAffiliateById_result()
1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
3431 rajveer 1841 
    if result.success is not None:
1845 vikas 1842 
      return result.success
3431 rajveer 1843 
    if result.utx is not None:
1845 vikas 1844 
      raise result.utx
1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1846 
 
1847 
  def getAffiliateByName(self, name):
1848 
    """
1849 
    Parameters:
1850 
     - name
1851 
    """
1852 
    self.send_getAffiliateByName(name)
1853 
    return self.recv_getAffiliateByName()
1854 
 
1855 
  def send_getAffiliateByName(self, name):
1856 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1857 
    args = getAffiliateByName_args()
1858 
    args.name = name
1859 
    args.write(self._oprot)
1860 
    self._oprot.writeMessageEnd()
1861 
    self._oprot.trans.flush()
1862 
 
1863 
  def recv_getAffiliateByName(self, ):
1864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1865 
    if mtype == TMessageType.EXCEPTION:
1866 
      x = TApplicationException()
1867 
      x.read(self._iprot)
1868 
      self._iprot.readMessageEnd()
1869 
      raise x
1870 
    result = getAffiliateByName_result()
1871 
    result.read(self._iprot)
1872 
    self._iprot.readMessageEnd()
3431 rajveer 1873 
    if result.success is not None:
1845 vikas 1874 
      return result.success
3431 rajveer 1875 
    if result.utx is not None:
1845 vikas 1876 
      raise result.utx
1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1878 
 
1996 vikas 1879 
  def getTrackerById(self, id):
1845 vikas 1880 
    """
1881 
    Parameters:
1882 
     - id
1883 
    """
1996 vikas 1884 
    self.send_getTrackerById(id)
1845 vikas 1885 
    return self.recv_getTrackerById()
1886 
 
1996 vikas 1887 
  def send_getTrackerById(self, id):
1845 vikas 1888 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1889 
    args = getTrackerById_args()
1996 vikas 1890 
    args.id = id
1845 vikas 1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getTrackerById(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getTrackerById_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
3431 rajveer 1905 
    if result.success is not None:
1845 vikas 1906 
      return result.success
3431 rajveer 1907 
    if result.utx is not None:
1845 vikas 1908 
      raise result.utx
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1910 
 
1996 vikas 1911 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1912 
    """
1913 
    Parameters:
1996 vikas 1914 
     - id
1845 vikas 1915 
    """
1996 vikas 1916 
    self.send_getAffiliatesByMasterAffiliate(id)
1917 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1918 
 
1996 vikas 1919 
  def send_getAffiliatesByMasterAffiliate(self, id):
1920 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1921 
    args = getAffiliatesByMasterAffiliate_args()
1922 
    args.id = id
1845 vikas 1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1996 vikas 1927 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1996 vikas 1934 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
3431 rajveer 1937 
    if result.success is not None:
1845 vikas 1938 
      return result.success
3431 rajveer 1939 
    if result.utx is not None:
1845 vikas 1940 
      raise result.utx
1996 vikas 1941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1942 
 
1996 vikas 1943 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1944 
    """
1945 
    Parameters:
1996 vikas 1946 
     - affiliateId
1845 vikas 1947 
     - userId
1948 
     - event
1949 
     - url
1950 
     - data
1859 vikas 1951 
     - addedOn
1845 vikas 1952 
    """
1996 vikas 1953 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1954 
    return self.recv_addTrackLog()
1955 
 
1996 vikas 1956 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1957 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1958 
    args = addTrackLog_args()
1996 vikas 1959 
    args.affiliateId = affiliateId
1845 vikas 1960 
    args.userId = userId
1961 
    args.event = event
1962 
    args.url = url
1963 
    args.data = data
1859 vikas 1964 
    args.addedOn = addedOn
1845 vikas 1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
1969 
  def recv_addTrackLog(self, ):
1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
1976 
    result = addTrackLog_result()
1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
3431 rajveer 1979 
    if result.success is not None:
1845 vikas 1980 
      return result.success
3431 rajveer 1981 
    if result.utx is not None:
1845 vikas 1982 
      raise result.utx
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1984 
 
1985 
  def getTrackLogById(self, id):
1986 
    """
1987 
    Parameters:
1988 
     - id
1989 
    """
1990 
    self.send_getTrackLogById(id)
1991 
    return self.recv_getTrackLogById()
1992 
 
1993 
  def send_getTrackLogById(self, id):
1994 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1995 
    args = getTrackLogById_args()
1996 
    args.id = id
1997 
    args.write(self._oprot)
1998 
    self._oprot.writeMessageEnd()
1999 
    self._oprot.trans.flush()
2000 
 
2001 
  def recv_getTrackLogById(self, ):
2002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2003 
    if mtype == TMessageType.EXCEPTION:
2004 
      x = TApplicationException()
2005 
      x.read(self._iprot)
2006 
      self._iprot.readMessageEnd()
2007 
      raise x
2008 
    result = getTrackLogById_result()
2009 
    result.read(self._iprot)
2010 
    self._iprot.readMessageEnd()
3431 rajveer 2011 
    if result.success is not None:
1845 vikas 2012 
      return result.success
3431 rajveer 2013 
    if result.utx is not None:
1845 vikas 2014 
      raise result.utx
2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2016 
 
3293 vikas 2017 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2018 
    """
2019 
    Parameters:
1996 vikas 2020 
     - affiliateId
3293 vikas 2021 
     - startDate
2022 
     - endDate
1845 vikas 2023 
    """
3293 vikas 2024 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2025 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2026 
 
3293 vikas 2027 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2028 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2029 
    args = getTrackLogsByAffiliate_args()
2030 
    args.affiliateId = affiliateId
3293 vikas 2031 
    args.startDate = startDate
2032 
    args.endDate = endDate
1845 vikas 2033 
    args.write(self._oprot)
2034 
    self._oprot.writeMessageEnd()
2035 
    self._oprot.trans.flush()
2036 
 
1996 vikas 2037 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2039 
    if mtype == TMessageType.EXCEPTION:
2040 
      x = TApplicationException()
2041 
      x.read(self._iprot)
2042 
      self._iprot.readMessageEnd()
2043 
      raise x
1996 vikas 2044 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2045 
    result.read(self._iprot)
2046 
    self._iprot.readMessageEnd()
3431 rajveer 2047 
    if result.success is not None:
1845 vikas 2048 
      return result.success
3431 rajveer 2049 
    if result.utx is not None:
1845 vikas 2050 
      raise result.utx
1996 vikas 2051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2052 
 
2053 
  def getTrackLogsByUser(self, userId):
2054 
    """
2055 
    Parameters:
2056 
     - userId
2057 
    """
2058 
    self.send_getTrackLogsByUser(userId)
2059 
    return self.recv_getTrackLogsByUser()
2060 
 
2061 
  def send_getTrackLogsByUser(self, userId):
2062 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2063 
    args = getTrackLogsByUser_args()
2064 
    args.userId = userId
2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getTrackLogsByUser(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getTrackLogsByUser_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
3431 rajveer 2079 
    if result.success is not None:
1845 vikas 2080 
      return result.success
3431 rajveer 2081 
    if result.utx is not None:
1845 vikas 2082 
      raise result.utx
2083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2084 
 
1996 vikas 2085 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2086 
    """
2087 
    Parameters:
2088 
     - userId
2089 
     - event
2090 
     - url
2091 
    """
1996 vikas 2092 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2093 
    return self.recv_getTrackLogs()
2094 
 
1996 vikas 2095 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2096 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2097 
    args = getTrackLogs_args()
2098 
    args.userId = userId
2099 
    args.event = event
2100 
    args.url = url
2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
2105 
  def recv_getTrackLogs(self, ):
2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
2112 
    result = getTrackLogs_result()
2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
1845 vikas 2116 
      return result.success
3431 rajveer 2117 
    if result.utx is not None:
1845 vikas 2118 
      raise result.utx
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2120 
 
559 chandransh 2121 
  def getCurrentCart(self, userId):
94 ashish 2122 
    """
2123 
    Parameters:
559 chandransh 2124 
     - userId
94 ashish 2125 
    """
559 chandransh 2126 
    self.send_getCurrentCart(userId)
2127 
    return self.recv_getCurrentCart()
94 ashish 2128 
 
559 chandransh 2129 
  def send_getCurrentCart(self, userId):
2130 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2131 
    args = getCurrentCart_args()
2132 
    args.userId = userId
94 ashish 2133 
    args.write(self._oprot)
2134 
    self._oprot.writeMessageEnd()
2135 
    self._oprot.trans.flush()
2136 
 
559 chandransh 2137 
  def recv_getCurrentCart(self, ):
94 ashish 2138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2139 
    if mtype == TMessageType.EXCEPTION:
2140 
      x = TApplicationException()
2141 
      x.read(self._iprot)
2142 
      self._iprot.readMessageEnd()
2143 
      raise x
559 chandransh 2144 
    result = getCurrentCart_result()
94 ashish 2145 
    result.read(self._iprot)
2146 
    self._iprot.readMessageEnd()
3431 rajveer 2147 
    if result.success is not None:
94 ashish 2148 
      return result.success
3431 rajveer 2149 
    if result.scx is not None:
559 chandransh 2150 
      raise result.scx
2151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2152 
 
559 chandransh 2153 
  def getCart(self, cartId):
94 ashish 2154 
    """
2155 
    Parameters:
559 chandransh 2156 
     - cartId
94 ashish 2157 
    """
559 chandransh 2158 
    self.send_getCart(cartId)
2159 
    return self.recv_getCart()
94 ashish 2160 
 
559 chandransh 2161 
  def send_getCart(self, cartId):
2162 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2163 
    args = getCart_args()
2164 
    args.cartId = cartId
94 ashish 2165 
    args.write(self._oprot)
2166 
    self._oprot.writeMessageEnd()
2167 
    self._oprot.trans.flush()
2168 
 
559 chandransh 2169 
  def recv_getCart(self, ):
94 ashish 2170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2171 
    if mtype == TMessageType.EXCEPTION:
2172 
      x = TApplicationException()
2173 
      x.read(self._iprot)
2174 
      self._iprot.readMessageEnd()
2175 
      raise x
559 chandransh 2176 
    result = getCart_result()
94 ashish 2177 
    result.read(self._iprot)
2178 
    self._iprot.readMessageEnd()
3431 rajveer 2179 
    if result.success is not None:
94 ashish 2180 
      return result.success
3431 rajveer 2181 
    if result.scx is not None:
559 chandransh 2182 
      raise result.scx
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2184 
 
559 chandransh 2185 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2186 
    """
2187 
    Parameters:
559 chandransh 2188 
     - from_time
2189 
     - to_time
2190 
     - status
94 ashish 2191 
    """
559 chandransh 2192 
    self.send_getCartsByTime(from_time, to_time, status)
2193 
    return self.recv_getCartsByTime()
94 ashish 2194 
 
559 chandransh 2195 
  def send_getCartsByTime(self, from_time, to_time, status):
2196 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2197 
    args = getCartsByTime_args()
2198 
    args.from_time = from_time
2199 
    args.to_time = to_time
2200 
    args.status = status
94 ashish 2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
559 chandransh 2205 
  def recv_getCartsByTime(self, ):
94 ashish 2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
559 chandransh 2212 
    result = getCartsByTime_result()
94 ashish 2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
3431 rajveer 2215 
    if result.success is not None:
94 ashish 2216 
      return result.success
3431 rajveer 2217 
    if result.scx is not None:
559 chandransh 2218 
      raise result.scx
2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2220 
 
3557 rajveer 2221 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2222 
    """
2223 
    Parameters:
2224 
     - cartId
2225 
     - itemId
2226 
     - quantity
3557 rajveer 2227 
     - sourceId
559 chandransh 2228 
    """
3557 rajveer 2229 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2230 
    return self.recv_addItemToCart()
559 chandransh 2231 
 
3557 rajveer 2232 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2233 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2234 
    args = addItemToCart_args()
2235 
    args.cartId = cartId
2236 
    args.itemId = itemId
2237 
    args.quantity = quantity
3557 rajveer 2238 
    args.sourceId = sourceId
559 chandransh 2239 
    args.write(self._oprot)
2240 
    self._oprot.writeMessageEnd()
2241 
    self._oprot.trans.flush()
2242 
 
2243 
  def recv_addItemToCart(self, ):
2244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2245 
    if mtype == TMessageType.EXCEPTION:
2246 
      x = TApplicationException()
2247 
      x.read(self._iprot)
2248 
      self._iprot.readMessageEnd()
2249 
      raise x
2250 
    result = addItemToCart_result()
2251 
    result.read(self._iprot)
2252 
    self._iprot.readMessageEnd()
3431 rajveer 2253 
    if result.success is not None:
2035 rajveer 2254 
      return result.success
3431 rajveer 2255 
    if result.scx is not None:
559 chandransh 2256 
      raise result.scx
2035 rajveer 2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2258 
 
2259 
  def deleteItemFromCart(self, cartId, itemId):
2260 
    """
2261 
    Parameters:
2262 
     - cartId
2263 
     - itemId
2264 
    """
2265 
    self.send_deleteItemFromCart(cartId, itemId)
2266 
    self.recv_deleteItemFromCart()
2267 
 
2268 
  def send_deleteItemFromCart(self, cartId, itemId):
2269 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2270 
    args = deleteItemFromCart_args()
2271 
    args.cartId = cartId
2272 
    args.itemId = itemId
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_deleteItemFromCart(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = deleteItemFromCart_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
3431 rajveer 2287 
    if result.scx is not None:
559 chandransh 2288 
      raise result.scx
2289 
    return
2290 
 
2291 
  def addAddressToCart(self, cartId, addressId):
2292 
    """
2293 
    Parameters:
2294 
     - cartId
2295 
     - addressId
2296 
    """
2297 
    self.send_addAddressToCart(cartId, addressId)
2298 
    self.recv_addAddressToCart()
2299 
 
2300 
  def send_addAddressToCart(self, cartId, addressId):
2301 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2302 
    args = addAddressToCart_args()
2303 
    args.cartId = cartId
2304 
    args.addressId = addressId
2305 
    args.write(self._oprot)
2306 
    self._oprot.writeMessageEnd()
2307 
    self._oprot.trans.flush()
2308 
 
2309 
  def recv_addAddressToCart(self, ):
2310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2311 
    if mtype == TMessageType.EXCEPTION:
2312 
      x = TApplicationException()
2313 
      x.read(self._iprot)
2314 
      self._iprot.readMessageEnd()
2315 
      raise x
2316 
    result = addAddressToCart_result()
2317 
    result.read(self._iprot)
2318 
    self._iprot.readMessageEnd()
3431 rajveer 2319 
    if result.scx is not None:
575 chandransh 2320 
      raise result.scx
559 chandransh 2321 
    return
2322 
 
5553 rajveer 2323 
  def addStoreToCart(self, cartId, storeId):
2324 
    """
2325 
    Parameters:
2326 
     - cartId
2327 
     - storeId
2328 
    """
2329 
    self.send_addStoreToCart(cartId, storeId)
2330 
    self.recv_addStoreToCart()
2331 
 
2332 
  def send_addStoreToCart(self, cartId, storeId):
2333 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2334 
    args = addStoreToCart_args()
2335 
    args.cartId = cartId
2336 
    args.storeId = storeId
2337 
    args.write(self._oprot)
2338 
    self._oprot.writeMessageEnd()
2339 
    self._oprot.trans.flush()
2340 
 
2341 
  def recv_addStoreToCart(self, ):
2342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2343 
    if mtype == TMessageType.EXCEPTION:
2344 
      x = TApplicationException()
2345 
      x.read(self._iprot)
2346 
      self._iprot.readMessageEnd()
2347 
      raise x
2348 
    result = addStoreToCart_result()
2349 
    result.read(self._iprot)
2350 
    self._iprot.readMessageEnd()
2351 
    if result.scx is not None:
2352 
      raise result.scx
2353 
    return
2354 
 
6922 anupam.sin 2355 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2356 
    """
2357 
    Parameters:
6922 anupam.sin 2358 
     - cart
1976 varun.gupt 2359 
     - couponCode
2360 
    """
6922 anupam.sin 2361 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2362 
    self.recv_applyCouponToCart()
2363 
 
6922 anupam.sin 2364 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2365 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2366 
    args = applyCouponToCart_args()
6922 anupam.sin 2367 
    args.cart = cart
1976 varun.gupt 2368 
    args.couponCode = couponCode
2369 
    args.write(self._oprot)
2370 
    self._oprot.writeMessageEnd()
2371 
    self._oprot.trans.flush()
2372 
 
2373 
  def recv_applyCouponToCart(self, ):
2374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2375 
    if mtype == TMessageType.EXCEPTION:
2376 
      x = TApplicationException()
2377 
      x.read(self._iprot)
2378 
      self._iprot.readMessageEnd()
2379 
      raise x
2380 
    result = applyCouponToCart_result()
2381 
    result.read(self._iprot)
2382 
    self._iprot.readMessageEnd()
3431 rajveer 2383 
    if result.scx is not None:
1976 varun.gupt 2384 
      raise result.scx
2385 
    return
2386 
 
2387 
  def removeCoupon(self, cartId):
2388 
    """
2389 
    Parameters:
2390 
     - cartId
2391 
    """
2392 
    self.send_removeCoupon(cartId)
2393 
    self.recv_removeCoupon()
2394 
 
2395 
  def send_removeCoupon(self, cartId):
2396 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2397 
    args = removeCoupon_args()
2398 
    args.cartId = cartId
2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
2403 
  def recv_removeCoupon(self, ):
2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
2410 
    result = removeCoupon_result()
2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
3431 rajveer 2413 
    if result.scx is not None:
1976 varun.gupt 2414 
      raise result.scx
2415 
    return
2416 
 
3554 varun.gupt 2417 
  def deleteDiscountsFromCart(self, cartId):
2418 
    """
2419 
    Deletes all the discounts associated with the cart
2420 
 
2421 
    Parameters:
2422 
     - cartId
2423 
    """
2424 
    self.send_deleteDiscountsFromCart(cartId)
2425 
    self.recv_deleteDiscountsFromCart()
2426 
 
2427 
  def send_deleteDiscountsFromCart(self, cartId):
2428 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2429 
    args = deleteDiscountsFromCart_args()
2430 
    args.cartId = cartId
2431 
    args.write(self._oprot)
2432 
    self._oprot.writeMessageEnd()
2433 
    self._oprot.trans.flush()
2434 
 
2435 
  def recv_deleteDiscountsFromCart(self, ):
2436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2437 
    if mtype == TMessageType.EXCEPTION:
2438 
      x = TApplicationException()
2439 
      x.read(self._iprot)
2440 
      self._iprot.readMessageEnd()
2441 
      raise x
2442 
    result = deleteDiscountsFromCart_result()
2443 
    result.read(self._iprot)
2444 
    self._iprot.readMessageEnd()
2445 
    if result.scx is not None:
2446 
      raise result.scx
2447 
    return
2448 
 
2449 
  def saveDiscounts(self, discounts):
2450 
    """
2451 
    Accepts a list of thrift objects of Discount type and saves them
2452 
 
2453 
    Parameters:
2454 
     - discounts
2455 
    """
2456 
    self.send_saveDiscounts(discounts)
2457 
    self.recv_saveDiscounts()
2458 
 
2459 
  def send_saveDiscounts(self, discounts):
2460 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2461 
    args = saveDiscounts_args()
2462 
    args.discounts = discounts
2463 
    args.write(self._oprot)
2464 
    self._oprot.writeMessageEnd()
2465 
    self._oprot.trans.flush()
2466 
 
2467 
  def recv_saveDiscounts(self, ):
2468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2469 
    if mtype == TMessageType.EXCEPTION:
2470 
      x = TApplicationException()
2471 
      x.read(self._iprot)
2472 
      self._iprot.readMessageEnd()
2473 
      raise x
2474 
    result = saveDiscounts_result()
2475 
    result.read(self._iprot)
2476 
    self._iprot.readMessageEnd()
2477 
    if result.scx is not None:
2478 
      raise result.scx
2479 
    return
2480 
 
11526 amit.gupta 2481 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2482 
    """
690 chandransh 2483 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2484 
 
559 chandransh 2485 
    Parameters:
2486 
     - cartId
2815 vikas 2487 
     - sessionSource
2488 
     - sessionStartTime
3858 vikas 2489 
     - firstSource
2490 
     - firstSourceTime
5326 rajveer 2491 
     - userId
6389 rajveer 2492 
     - schemeId
11526 amit.gupta 2493 
     - orderSource
559 chandransh 2494 
    """
11526 amit.gupta 2495 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2496 
    return self.recv_createOrders()
559 chandransh 2497 
 
11526 amit.gupta 2498 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2499 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2500 
    args = createOrders_args()
559 chandransh 2501 
    args.cartId = cartId
2815 vikas 2502 
    args.sessionSource = sessionSource
2503 
    args.sessionStartTime = sessionStartTime
3858 vikas 2504 
    args.firstSource = firstSource
2505 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2506 
    args.userId = userId
6389 rajveer 2507 
    args.schemeId = schemeId
11526 amit.gupta 2508 
    args.orderSource = orderSource
559 chandransh 2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
690 chandransh 2513 
  def recv_createOrders(self, ):
559 chandransh 2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
690 chandransh 2520 
    result = createOrders_result()
559 chandransh 2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
3431 rajveer 2523 
    if result.success is not None:
130 ashish 2524 
      return result.success
3431 rajveer 2525 
    if result.scx is not None:
559 chandransh 2526 
      raise result.scx
690 chandransh 2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2528 
 
3557 rajveer 2529 
  def validateCart(self, cartId, sourceId):
130 ashish 2530 
    """
690 chandransh 2531 
    Validates that:
2532 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2533 
    2. All of the lines in the cart are active items.
690 chandransh 2534 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2535 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2536 
 
130 ashish 2537 
    Parameters:
559 chandransh 2538 
     - cartId
3557 rajveer 2539 
     - sourceId
130 ashish 2540 
    """
3557 rajveer 2541 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2542 
    return self.recv_validateCart()
130 ashish 2543 
 
3557 rajveer 2544 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2545 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2546 
    args = validateCart_args()
2547 
    args.cartId = cartId
3557 rajveer 2548 
    args.sourceId = sourceId
130 ashish 2549 
    args.write(self._oprot)
2550 
    self._oprot.writeMessageEnd()
2551 
    self._oprot.trans.flush()
2552 
 
559 chandransh 2553 
  def recv_validateCart(self, ):
130 ashish 2554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2555 
    if mtype == TMessageType.EXCEPTION:
2556 
      x = TApplicationException()
2557 
      x.read(self._iprot)
2558 
      self._iprot.readMessageEnd()
2559 
      raise x
559 chandransh 2560 
    result = validateCart_result()
130 ashish 2561 
    result.read(self._iprot)
2562 
    self._iprot.readMessageEnd()
3431 rajveer 2563 
    if result.success is not None:
130 ashish 2564 
      return result.success
3431 rajveer 2565 
    if result.scex is not None:
575 chandransh 2566 
      raise result.scex
559 chandransh 2567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2568 
 
11980 amit.gupta 2569 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2570 
    """
2571 
    Validates that:
2572 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2573 
    2. All of the lines in the cart are active items.
2574 
    3. The estimate for any of the lines in cart doesn't change.
2575 
    If all three are true, returns empty string; else returns appropriate message.
2576 
 
2577 
    Parameters:
2578 
     - cartId
2579 
     - sourceId
2580 
     - dealCoupon
2581 
    """
2582 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2583 
    return self.recv_validateCartWithDealerCoupon()
2584 
 
2585 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2586 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2587 
    args = validateCartWithDealerCoupon_args()
2588 
    args.cartId = cartId
2589 
    args.sourceId = sourceId
2590 
    args.dealCoupon = dealCoupon
2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2595 
  def recv_validateCartWithDealerCoupon(self, ):
2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2602 
    result = validateCartWithDealerCoupon_result()
2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
2605 
    if result.success is not None:
2606 
      return result.success
2607 
    if result.scex is not None:
2608 
      raise result.scex
2609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2610 
 
690 chandransh 2611 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2612 
    """
690 chandransh 2613 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2614 
 
575 chandransh 2615 
    Parameters:
690 chandransh 2616 
     - fromCartId
2617 
     - toCartId
2618 
    """
2619 
    self.send_mergeCart(fromCartId, toCartId)
2620 
    self.recv_mergeCart()
2621 
 
2622 
  def send_mergeCart(self, fromCartId, toCartId):
2623 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2624 
    args = mergeCart_args()
2625 
    args.fromCartId = fromCartId
2626 
    args.toCartId = toCartId
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_mergeCart(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = mergeCart_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    return
2642 
 
2643 
  def checkOut(self, cartId):
2644 
    """
2645 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2646 
 
690 chandransh 2647 
    Parameters:
575 chandransh 2648 
     - cartId
2649 
    """
690 chandransh 2650 
    self.send_checkOut(cartId)
2651 
    return self.recv_checkOut()
575 chandransh 2652 
 
690 chandransh 2653 
  def send_checkOut(self, cartId):
2654 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2655 
    args = checkOut_args()
575 chandransh 2656 
    args.cartId = cartId
2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
690 chandransh 2661 
  def recv_checkOut(self, ):
575 chandransh 2662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2663 
    if mtype == TMessageType.EXCEPTION:
2664 
      x = TApplicationException()
2665 
      x.read(self._iprot)
2666 
      self._iprot.readMessageEnd()
2667 
      raise x
690 chandransh 2668 
    result = checkOut_result()
575 chandransh 2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
3431 rajveer 2671 
    if result.success is not None:
575 chandransh 2672 
      return result.success
3431 rajveer 2673 
    if result.scex is not None:
575 chandransh 2674 
      raise result.scex
690 chandransh 2675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2676 
 
690 chandransh 2677 
  def resetCart(self, cartId, items):
559 chandransh 2678 
    """
690 chandransh 2679 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2680 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2681 
 
559 chandransh 2682 
    Parameters:
690 chandransh 2683 
     - cartId
2684 
     - items
559 chandransh 2685 
    """
690 chandransh 2686 
    self.send_resetCart(cartId, items)
2687 
    return self.recv_resetCart()
130 ashish 2688 
 
690 chandransh 2689 
  def send_resetCart(self, cartId, items):
2690 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2691 
    args = resetCart_args()
2692 
    args.cartId = cartId
2693 
    args.items = items
559 chandransh 2694 
    args.write(self._oprot)
2695 
    self._oprot.writeMessageEnd()
2696 
    self._oprot.trans.flush()
2697 
 
690 chandransh 2698 
  def recv_resetCart(self, ):
559 chandransh 2699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2700 
    if mtype == TMessageType.EXCEPTION:
2701 
      x = TApplicationException()
2702 
      x.read(self._iprot)
2703 
      self._iprot.readMessageEnd()
2704 
      raise x
690 chandransh 2705 
    result = resetCart_result()
559 chandransh 2706 
    result.read(self._iprot)
2707 
    self._iprot.readMessageEnd()
3431 rajveer 2708 
    if result.success is not None:
690 chandransh 2709 
      return result.success
3431 rajveer 2710 
    if result.scex is not None:
690 chandransh 2711 
      raise result.scex
2712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2713 
 
2981 rajveer 2714 
  def getUserCount(self, userType):
559 chandransh 2715 
    """
2981 rajveer 2716 
    Returns number of registered users.
2717 
    If userType = null, then it returns count of all users, including anonymous
2718 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2719 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2720 
 
559 chandransh 2721 
    Parameters:
2981 rajveer 2722 
     - userType
559 chandransh 2723 
    """
2981 rajveer 2724 
    self.send_getUserCount(userType)
2725 
    return self.recv_getUserCount()
559 chandransh 2726 
 
2981 rajveer 2727 
  def send_getUserCount(self, userType):
2728 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2729 
    args = getUserCount_args()
2730 
    args.userType = userType
559 chandransh 2731 
    args.write(self._oprot)
2732 
    self._oprot.writeMessageEnd()
2733 
    self._oprot.trans.flush()
2734 
 
2981 rajveer 2735 
  def recv_getUserCount(self, ):
559 chandransh 2736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2737 
    if mtype == TMessageType.EXCEPTION:
2738 
      x = TApplicationException()
2739 
      x.read(self._iprot)
2740 
      self._iprot.readMessageEnd()
2741 
      raise x
2981 rajveer 2742 
    result = getUserCount_result()
559 chandransh 2743 
    result.read(self._iprot)
2744 
    self._iprot.readMessageEnd()
3431 rajveer 2745 
    if result.success is not None:
559 chandransh 2746 
      return result.success
2981 rajveer 2747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2748 
 
2981 rajveer 2749 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2750 
    """
2981 rajveer 2751 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2752 
    If any of startDate or endDate is -1, then that filter is ignored.
2753 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2754 
 
2755 
 
559 chandransh 2756 
    Parameters:
2981 rajveer 2757 
     - userType
2758 
     - startDate
2759 
     - endDate
559 chandransh 2760 
    """
2981 rajveer 2761 
    self.send_getAllUsers(userType, startDate, endDate)
2762 
    return self.recv_getAllUsers()
559 chandransh 2763 
 
2981 rajveer 2764 
  def send_getAllUsers(self, userType, startDate, endDate):
2765 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2766 
    args = getAllUsers_args()
2767 
    args.userType = userType
2768 
    args.startDate = startDate
2769 
    args.endDate = endDate
559 chandransh 2770 
    args.write(self._oprot)
2771 
    self._oprot.writeMessageEnd()
2772 
    self._oprot.trans.flush()
2773 
 
2981 rajveer 2774 
  def recv_getAllUsers(self, ):
559 chandransh 2775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2776 
    if mtype == TMessageType.EXCEPTION:
2777 
      x = TApplicationException()
2778 
      x.read(self._iprot)
2779 
      self._iprot.readMessageEnd()
2780 
      raise x
2981 rajveer 2781 
    result = getAllUsers_result()
559 chandransh 2782 
    result.read(self._iprot)
2783 
    self._iprot.readMessageEnd()
3431 rajveer 2784 
    if result.success is not None:
559 chandransh 2785 
      return result.success
2981 rajveer 2786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2787 
 
2981 rajveer 2788 
  def getMyResearchItems(self, userId):
559 chandransh 2789 
    """
2981 rajveer 2790 
    Returns list of item ids in myresearch for the user
3431 rajveer 2791 
 
559 chandransh 2792 
    Parameters:
772 rajveer 2793 
     - userId
559 chandransh 2794 
    """
2981 rajveer 2795 
    self.send_getMyResearchItems(userId)
2796 
    return self.recv_getMyResearchItems()
559 chandransh 2797 
 
2981 rajveer 2798 
  def send_getMyResearchItems(self, userId):
2799 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2800 
    args = getMyResearchItems_args()
772 rajveer 2801 
    args.userId = userId
559 chandransh 2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2981 rajveer 2806 
  def recv_getMyResearchItems(self, ):
559 chandransh 2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2981 rajveer 2813 
    result = getMyResearchItems_result()
559 chandransh 2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
3431 rajveer 2816 
    if result.success is not None:
559 chandransh 2817 
      return result.success
3431 rajveer 2818 
    if result.scx is not None:
559 chandransh 2819 
      raise result.scx
2981 rajveer 2820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2821 
 
2981 rajveer 2822 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2823 
    """
2981 rajveer 2824 
    add item to my research for a user
3431 rajveer 2825 
 
559 chandransh 2826 
    Parameters:
2981 rajveer 2827 
     - userId
2828 
     - itemId
559 chandransh 2829 
    """
2981 rajveer 2830 
    self.send_updateMyResearch(userId, itemId)
2831 
    return self.recv_updateMyResearch()
559 chandransh 2832 
 
2981 rajveer 2833 
  def send_updateMyResearch(self, userId, itemId):
2834 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2835 
    args = updateMyResearch_args()
2836 
    args.userId = userId
2837 
    args.itemId = itemId
559 chandransh 2838 
    args.write(self._oprot)
2839 
    self._oprot.writeMessageEnd()
2840 
    self._oprot.trans.flush()
2841 
 
2981 rajveer 2842 
  def recv_updateMyResearch(self, ):
559 chandransh 2843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2844 
    if mtype == TMessageType.EXCEPTION:
2845 
      x = TApplicationException()
2846 
      x.read(self._iprot)
2847 
      self._iprot.readMessageEnd()
2848 
      raise x
2981 rajveer 2849 
    result = updateMyResearch_result()
559 chandransh 2850 
    result.read(self._iprot)
2851 
    self._iprot.readMessageEnd()
3431 rajveer 2852 
    if result.success is not None:
2981 rajveer 2853 
      return result.success
3431 rajveer 2854 
    if result.scx is not None:
2981 rajveer 2855 
      raise result.scx
2856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2857 
 
2981 rajveer 2858 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2859 
    """
2981 rajveer 2860 
    delete item from my research for a user
3431 rajveer 2861 
 
1596 ankur.sing 2862 
    Parameters:
2981 rajveer 2863 
     - userId
2864 
     - itemId
1596 ankur.sing 2865 
    """
2981 rajveer 2866 
    self.send_deleteItemFromMyResearch(userId, itemId)
2867 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2868 
 
2981 rajveer 2869 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2870 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2871 
    args = deleteItemFromMyResearch_args()
2872 
    args.userId = userId
2873 
    args.itemId = itemId
1596 ankur.sing 2874 
    args.write(self._oprot)
2875 
    self._oprot.writeMessageEnd()
2876 
    self._oprot.trans.flush()
2877 
 
2981 rajveer 2878 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2880 
    if mtype == TMessageType.EXCEPTION:
2881 
      x = TApplicationException()
2882 
      x.read(self._iprot)
2883 
      self._iprot.readMessageEnd()
2884 
      raise x
2981 rajveer 2885 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2886 
    result.read(self._iprot)
2887 
    self._iprot.readMessageEnd()
3431 rajveer 2888 
    if result.scx is not None:
2981 rajveer 2889 
      raise result.scx
2890 
    return
1596 ankur.sing 2891 
 
2981 rajveer 2892 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2893 
    """
2981 rajveer 2894 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2895 
 
1673 ankur.sing 2896 
    Parameters:
2981 rajveer 2897 
     - userId
1673 ankur.sing 2898 
    """
2981 rajveer 2899 
    self.send_getBrowseHistoryItems(userId)
2900 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2901 
 
2981 rajveer 2902 
  def send_getBrowseHistoryItems(self, userId):
2903 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2904 
    args = getBrowseHistoryItems_args()
2905 
    args.userId = userId
1673 ankur.sing 2906 
    args.write(self._oprot)
2907 
    self._oprot.writeMessageEnd()
2908 
    self._oprot.trans.flush()
2909 
 
2981 rajveer 2910 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2912 
    if mtype == TMessageType.EXCEPTION:
2913 
      x = TApplicationException()
2914 
      x.read(self._iprot)
2915 
      self._iprot.readMessageEnd()
2916 
      raise x
2981 rajveer 2917 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2918 
    result.read(self._iprot)
2919 
    self._iprot.readMessageEnd()
3431 rajveer 2920 
    if result.success is not None:
1673 ankur.sing 2921 
      return result.success
3431 rajveer 2922 
    if result.scx is not None:
2981 rajveer 2923 
      raise result.scx
2924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2925 
 
2981 rajveer 2926 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2927 
    """
2981 rajveer 2928 
    add item to browse history for a user
3431 rajveer 2929 
 
2642 varun.gupt 2930 
    Parameters:
2981 rajveer 2931 
     - userId
2932 
     - itemId
2642 varun.gupt 2933 
    """
2981 rajveer 2934 
    self.send_updateBrowseHistory(userId, itemId)
2935 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2936 
 
2981 rajveer 2937 
  def send_updateBrowseHistory(self, userId, itemId):
2938 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2939 
    args = updateBrowseHistory_args()
2940 
    args.userId = userId
2941 
    args.itemId = itemId
2642 varun.gupt 2942 
    args.write(self._oprot)
2943 
    self._oprot.writeMessageEnd()
2944 
    self._oprot.trans.flush()
2945 
 
2981 rajveer 2946 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2948 
    if mtype == TMessageType.EXCEPTION:
2949 
      x = TApplicationException()
2950 
      x.read(self._iprot)
2951 
      self._iprot.readMessageEnd()
2952 
      raise x
2981 rajveer 2953 
    result = updateBrowseHistory_result()
2642 varun.gupt 2954 
    result.read(self._iprot)
2955 
    self._iprot.readMessageEnd()
2956 
    return
2957 
 
3385 varun.gupt 2958 
  def getCartsWithCouponCount(self, couponCode):
2959 
    """
2960 
    Returns count of Carts with given coupon applied
3431 rajveer 2961 
 
3385 varun.gupt 2962 
    Parameters:
2963 
     - couponCode
2964 
    """
2965 
    self.send_getCartsWithCouponCount(couponCode)
2966 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2967 
 
3385 varun.gupt 2968 
  def send_getCartsWithCouponCount(self, couponCode):
2969 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2970 
    args = getCartsWithCouponCount_args()
2971 
    args.couponCode = couponCode
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_getCartsWithCouponCount(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = getCartsWithCouponCount_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
3431 rajveer 2986 
    if result.success is not None:
3385 varun.gupt 2987 
      return result.success
2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2989 
 
3499 mandeep.dh 2990 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2991 
    """
2992 
    Updates COD trust level of a user
3385 varun.gupt 2993 
 
3499 mandeep.dh 2994 
    Parameters:
2995 
     - userId
2996 
     - trustLevelDelta
2997 
    """
2998 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2999 
 
3000 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
3001 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
3002 
    args = increaseTrustLevel_args()
3003 
    args.userId = userId
3004 
    args.trustLevelDelta = trustLevelDelta
3005 
    args.write(self._oprot)
3006 
    self._oprot.writeMessageEnd()
3007 
    self._oprot.trans.flush()
5407 amar.kumar 3008 
  def getTrustLevel(self, userId):
3009 
    """
3010 
    Get trust level of a user
3011 
 
3012 
    Parameters:
3013 
     - userId
3014 
    """
3015 
    self.send_getTrustLevel(userId)
3016 
    return self.recv_getTrustLevel()
3017 
 
3018 
  def send_getTrustLevel(self, userId):
3019 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3020 
    args = getTrustLevel_args()
3021 
    args.userId = userId
3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_getTrustLevel(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = getTrustLevel_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3036 
    if result.success is not None:
3037 
      return result.success
3038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3039 
 
4668 varun.gupt 3040 
  def showCODOption(self, cartId, sourceId, pincode):
3041 
    """
3042 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3043 
 
4668 varun.gupt 3044 
    Parameters:
3045 
     - cartId
3046 
     - sourceId
3047 
     - pincode
3048 
    """
3049 
    self.send_showCODOption(cartId, sourceId, pincode)
3050 
    return self.recv_showCODOption()
3051 
 
3052 
  def send_showCODOption(self, cartId, sourceId, pincode):
3053 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3054 
    args = showCODOption_args()
3055 
    args.cartId = cartId
3056 
    args.sourceId = sourceId
3057 
    args.pincode = pincode
3058 
    args.write(self._oprot)
3059 
    self._oprot.writeMessageEnd()
3060 
    self._oprot.trans.flush()
3061 
 
3062 
  def recv_showCODOption(self, ):
3063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3064 
    if mtype == TMessageType.EXCEPTION:
3065 
      x = TApplicationException()
3066 
      x.read(self._iprot)
3067 
      self._iprot.readMessageEnd()
3068 
      raise x
3069 
    result = showCODOption_result()
3070 
    result.read(self._iprot)
3071 
    self._iprot.readMessageEnd()
3072 
    if result.success is not None:
3073 
      return result.success
3074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3075 
 
5623 anupam.sin 3076 
  def getUserEmails(self, startDate, endDate):
3077 
    """
3078 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3079 
 
5623 anupam.sin 3080 
    Parameters:
3081 
     - startDate
3082 
     - endDate
3083 
    """
3084 
    self.send_getUserEmails(startDate, endDate)
3085 
    return self.recv_getUserEmails()
3086 
 
3087 
  def send_getUserEmails(self, startDate, endDate):
3088 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3089 
    args = getUserEmails_args()
3090 
    args.startDate = startDate
3091 
    args.endDate = endDate
3092 
    args.write(self._oprot)
3093 
    self._oprot.writeMessageEnd()
3094 
    self._oprot.trans.flush()
3095 
 
3096 
  def recv_getUserEmails(self, ):
3097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3098 
    if mtype == TMessageType.EXCEPTION:
3099 
      x = TApplicationException()
3100 
      x.read(self._iprot)
3101 
      self._iprot.readMessageEnd()
3102 
      raise x
3103 
    result = getUserEmails_result()
3104 
    result.read(self._iprot)
3105 
    self._iprot.readMessageEnd()
3106 
    if result.success is not None:
3107 
      return result.success
3108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3109 
 
9299 kshitij.so 3110 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3111 
    """
3112 
    Mark a cart lineitem as insured. Returns true/false.
3113 
 
3114 
    Parameters:
3115 
     - itemId
3116 
     - cartId
3117 
     - toInsure
9299 kshitij.so 3118 
     - insurerType
6903 anupam.sin 3119 
    """
9299 kshitij.so 3120 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3121 
    return self.recv_insureItem()
3122 
 
9299 kshitij.so 3123 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3124 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3125 
    args = insureItem_args()
3126 
    args.itemId = itemId
3127 
    args.cartId = cartId
3128 
    args.toInsure = toInsure
9299 kshitij.so 3129 
    args.insurerType = insurerType
6903 anupam.sin 3130 
    args.write(self._oprot)
3131 
    self._oprot.writeMessageEnd()
3132 
    self._oprot.trans.flush()
3133 
 
3134 
  def recv_insureItem(self, ):
3135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3136 
    if mtype == TMessageType.EXCEPTION:
3137 
      x = TApplicationException()
3138 
      x.read(self._iprot)
3139 
      self._iprot.readMessageEnd()
3140 
      raise x
3141 
    result = insureItem_result()
3142 
    result.read(self._iprot)
3143 
    self._iprot.readMessageEnd()
3144 
    if result.success is not None:
3145 
      return result.success
3146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3147 
 
3148 
  def cancelInsurance(self, cartId):
3149 
    """
3150 
    Cancel insurance for all items in the cart
3151 
 
3152 
    Parameters:
3153 
     - cartId
3154 
    """
3155 
    self.send_cancelInsurance(cartId)
3156 
    return self.recv_cancelInsurance()
3157 
 
3158 
  def send_cancelInsurance(self, cartId):
3159 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3160 
    args = cancelInsurance_args()
3161 
    args.cartId = cartId
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_cancelInsurance(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = cancelInsurance_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3176 
    if result.success is not None:
3177 
      return result.success
3178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3179 
 
3180 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3181 
    """
3182 
    Stores insurance specific details like date of birth and guardianName
3183 
 
3184 
    Parameters:
3185 
     - addressId
3186 
     - dob
3187 
     - guardianName
3188 
    """
3189 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3190 
    return self.recv_storeInsuranceSpecificDetails()
3191 
 
3192 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3193 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3194 
    args = storeInsuranceSpecificDetails_args()
3195 
    args.addressId = addressId
3196 
    args.dob = dob
3197 
    args.guardianName = guardianName
3198 
    args.write(self._oprot)
3199 
    self._oprot.writeMessageEnd()
3200 
    self._oprot.trans.flush()
3201 
 
3202 
  def recv_storeInsuranceSpecificDetails(self, ):
3203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3204 
    if mtype == TMessageType.EXCEPTION:
3205 
      x = TApplicationException()
3206 
      x.read(self._iprot)
3207 
      self._iprot.readMessageEnd()
3208 
      raise x
3209 
    result = storeInsuranceSpecificDetails_result()
3210 
    result.read(self._iprot)
3211 
    self._iprot.readMessageEnd()
3212 
    if result.success is not None:
3213 
      return result.success
3214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3215 
 
3216 
  def isInsuranceDetailPresent(self, addressId):
3217 
    """
3218 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3219 
 
3220 
    Parameters:
3221 
     - addressId
3222 
    """
3223 
    self.send_isInsuranceDetailPresent(addressId)
3224 
    return self.recv_isInsuranceDetailPresent()
3225 
 
3226 
  def send_isInsuranceDetailPresent(self, addressId):
3227 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3228 
    args = isInsuranceDetailPresent_args()
3229 
    args.addressId = addressId
3230 
    args.write(self._oprot)
3231 
    self._oprot.writeMessageEnd()
3232 
    self._oprot.trans.flush()
3233 
 
3234 
  def recv_isInsuranceDetailPresent(self, ):
3235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3236 
    if mtype == TMessageType.EXCEPTION:
3237 
      x = TApplicationException()
3238 
      x.read(self._iprot)
3239 
      self._iprot.readMessageEnd()
3240 
      raise x
3241 
    result = isInsuranceDetailPresent_result()
3242 
    result.read(self._iprot)
3243 
    self._iprot.readMessageEnd()
3244 
    if result.success is not None:
3245 
      return result.success
3246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3247 
 
9791 rajveer 3248 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3249 
    """
9791 rajveer 3250 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3251 
 
6821 amar.kumar 3252 
    Parameters:
3253 
     - startDate
3254 
     - endDate
3255 
    """
9791 rajveer 3256 
    self.send_getProductsAddedToCart(startDate, endDate)
3257 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3258 
 
9791 rajveer 3259 
  def send_getProductsAddedToCart(self, startDate, endDate):
3260 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3261 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3262 
    args.startDate = startDate
3263 
    args.endDate = endDate
3264 
    args.write(self._oprot)
3265 
    self._oprot.writeMessageEnd()
3266 
    self._oprot.trans.flush()
3267 
 
9791 rajveer 3268 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3270 
    if mtype == TMessageType.EXCEPTION:
3271 
      x = TApplicationException()
3272 
      x.read(self._iprot)
3273 
      self._iprot.readMessageEnd()
3274 
      raise x
9791 rajveer 3275 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3276 
    result.read(self._iprot)
3277 
    self._iprot.readMessageEnd()
3278 
    if result.success is not None:
3279 
      return result.success
9791 rajveer 3280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3281 
 
11980 amit.gupta 3282 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3283 
    """
3284 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3285 
 
11592 amit.gupta 3286 
    Parameters:
3287 
     - cartId
3288 
     - sourceId
11980 amit.gupta 3289 
     - dealerCoupon
11592 amit.gupta 3290 
    """
11980 amit.gupta 3291 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3292 
    return self.recv_validateCartPlus()
3293 
 
11980 amit.gupta 3294 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3295 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3296 
    args = validateCartPlus_args()
3297 
    args.cartId = cartId
3298 
    args.sourceId = sourceId
11980 amit.gupta 3299 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3300 
    args.write(self._oprot)
3301 
    self._oprot.writeMessageEnd()
3302 
    self._oprot.trans.flush()
3303 
 
3304 
  def recv_validateCartPlus(self, ):
3305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3306 
    if mtype == TMessageType.EXCEPTION:
3307 
      x = TApplicationException()
3308 
      x.read(self._iprot)
3309 
      self._iprot.readMessageEnd()
3310 
      raise x
3311 
    result = validateCartPlus_result()
3312 
    result.read(self._iprot)
3313 
    self._iprot.readMessageEnd()
3314 
    if result.success is not None:
3315 
      return result.success
3316 
    if result.scex is not None:
3317 
      raise result.scex
3318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3319 
 
11679 vikram.rag 3320 
  def isPrivateDealUser(self, userId):
3321 
    """
3322 
    Parameters:
3323 
     - userId
3324 
    """
3325 
    self.send_isPrivateDealUser(userId)
3326 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3327 
 
11679 vikram.rag 3328 
  def send_isPrivateDealUser(self, userId):
3329 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3330 
    args = isPrivateDealUser_args()
3331 
    args.userId = userId
3332 
    args.write(self._oprot)
3333 
    self._oprot.writeMessageEnd()
3334 
    self._oprot.trans.flush()
3335 
 
3336 
  def recv_isPrivateDealUser(self, ):
3337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3338 
    if mtype == TMessageType.EXCEPTION:
3339 
      x = TApplicationException()
3340 
      x.read(self._iprot)
3341 
      self._iprot.readMessageEnd()
3342 
      raise x
3343 
    result = isPrivateDealUser_result()
3344 
    result.read(self._iprot)
3345 
    self._iprot.readMessageEnd()
3346 
    if result.success is not None:
3347 
      return result.success
3348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3349 
 
11890 kshitij.so 3350 
  def addPrivateDealUser(self, userId):
3351 
    """
3352 
    Parameters:
3353 
     - userId
3354 
    """
3355 
    self.send_addPrivateDealUser(userId)
3356 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3357 
 
11890 kshitij.so 3358 
  def send_addPrivateDealUser(self, userId):
3359 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3360 
    args = addPrivateDealUser_args()
3361 
    args.userId = userId
3362 
    args.write(self._oprot)
3363 
    self._oprot.writeMessageEnd()
3364 
    self._oprot.trans.flush()
3365 
 
3366 
  def recv_addPrivateDealUser(self, ):
3367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3368 
    if mtype == TMessageType.EXCEPTION:
3369 
      x = TApplicationException()
3370 
      x.read(self._iprot)
3371 
      self._iprot.readMessageEnd()
3372 
      raise x
3373 
    result = addPrivateDealUser_result()
3374 
    result.read(self._iprot)
3375 
    self._iprot.readMessageEnd()
3376 
    if result.success is not None:
3377 
      return result.success
3378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3379 
 
3380 
  def changePrivateDealUserStatus(self, userId, isActive):
3381 
    """
3382 
    Parameters:
3383 
     - userId
3384 
     - isActive
3385 
    """
3386 
    self.send_changePrivateDealUserStatus(userId, isActive)
3387 
    return self.recv_changePrivateDealUserStatus()
3388 
 
3389 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3390 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3391 
    args = changePrivateDealUserStatus_args()
3392 
    args.userId = userId
3393 
    args.isActive = isActive
3394 
    args.write(self._oprot)
3395 
    self._oprot.writeMessageEnd()
3396 
    self._oprot.trans.flush()
3397 
 
3398 
  def recv_changePrivateDealUserStatus(self, ):
3399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3400 
    if mtype == TMessageType.EXCEPTION:
3401 
      x = TApplicationException()
3402 
      x.read(self._iprot)
3403 
      self._iprot.readMessageEnd()
3404 
      raise x
3405 
    result = changePrivateDealUserStatus_result()
3406 
    result.read(self._iprot)
3407 
    self._iprot.readMessageEnd()
3408 
    if result.success is not None:
3409 
      return result.success
3410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3411 
 
3412 
  def getPrivateDealUser(self, userId):
3413 
    """
3414 
    Parameters:
3415 
     - userId
3416 
    """
3417 
    self.send_getPrivateDealUser(userId)
3418 
    return self.recv_getPrivateDealUser()
3419 
 
3420 
  def send_getPrivateDealUser(self, userId):
3421 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3422 
    args = getPrivateDealUser_args()
3423 
    args.userId = userId
3424 
    args.write(self._oprot)
3425 
    self._oprot.writeMessageEnd()
3426 
    self._oprot.trans.flush()
3427 
 
3428 
  def recv_getPrivateDealUser(self, ):
3429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3430 
    if mtype == TMessageType.EXCEPTION:
3431 
      x = TApplicationException()
3432 
      x.read(self._iprot)
3433 
      self._iprot.readMessageEnd()
3434 
      raise x
3435 
    result = getPrivateDealUser_result()
3436 
    result.read(self._iprot)
3437 
    self._iprot.readMessageEnd()
3438 
    if result.success is not None:
3439 
      return result.success
3440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3441 
 
12696 amit.gupta 3442 
  def registerCounter(self, counter, userId):
3443 
    """
3444 
    Parameters:
3445 
     - counter
3446 
     - userId
3447 
    """
3448 
    self.send_registerCounter(counter, userId)
3449 
    return self.recv_registerCounter()
11890 kshitij.so 3450 
 
12696 amit.gupta 3451 
  def send_registerCounter(self, counter, userId):
3452 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3453 
    args = registerCounter_args()
3454 
    args.counter = counter
3455 
    args.userId = userId
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_registerCounter(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = registerCounter_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    if result.success is not None:
3471 
      return result.success
3472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3473 
 
12722 amit.gupta 3474 
  def searchCounter(self, type1, searchString):
3475 
    """
3476 
    Parameters:
3477 
     - type1
3478 
     - searchString
3479 
    """
3480 
    self.send_searchCounter(type1, searchString)
3481 
    return self.recv_searchCounter()
12696 amit.gupta 3482 
 
12722 amit.gupta 3483 
  def send_searchCounter(self, type1, searchString):
3484 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3485 
    args = searchCounter_args()
3486 
    args.type1 = type1
3487 
    args.searchString = searchString
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_searchCounter(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = searchCounter_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    if result.success is not None:
3503 
      return result.success
3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3505 
 
18977 amit.gupta 3506 
  def getCounterByUserId(self, userId):
3507 
    """
3508 
    Parameters:
3509 
     - userId
3510 
    """
3511 
    self.send_getCounterByUserId(userId)
3512 
    return self.recv_getCounterByUserId()
3513 
 
3514 
  def send_getCounterByUserId(self, userId):
3515 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3516 
    args = getCounterByUserId_args()
3517 
    args.userId = userId
3518 
    args.write(self._oprot)
3519 
    self._oprot.writeMessageEnd()
3520 
    self._oprot.trans.flush()
3521 
 
3522 
  def recv_getCounterByUserId(self, ):
3523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3524 
    if mtype == TMessageType.EXCEPTION:
3525 
      x = TApplicationException()
3526 
      x.read(self._iprot)
3527 
      self._iprot.readMessageEnd()
3528 
      raise x
3529 
    result = getCounterByUserId_result()
3530 
    result.read(self._iprot)
3531 
    self._iprot.readMessageEnd()
3532 
    if result.success is not None:
3533 
      return result.success
3534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3535 
 
12722 amit.gupta 3536 
  def getAllUsersByCounter(self, counterId):
3537 
    """
3538 
    Parameters:
3539 
     - counterId
3540 
    """
3541 
    self.send_getAllUsersByCounter(counterId)
3542 
    return self.recv_getAllUsersByCounter()
3543 
 
3544 
  def send_getAllUsersByCounter(self, counterId):
3545 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3546 
    args = getAllUsersByCounter_args()
3547 
    args.counterId = counterId
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getAllUsersByCounter(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getAllUsersByCounter_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    if result.success is not None:
3563 
      return result.success
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3565 
 
15251 manish.sha 3566 
  def getActiveAccessTokenForUser(self, userId, source):
3567 
    """
3568 
    Parameters:
3569 
     - userId
3570 
     - source
3571 
    """
3572 
    self.send_getActiveAccessTokenForUser(userId, source)
3573 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3574 
 
15251 manish.sha 3575 
  def send_getActiveAccessTokenForUser(self, userId, source):
3576 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3577 
    args = getActiveAccessTokenForUser_args()
3578 
    args.userId = userId
3579 
    args.source = source
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_getActiveAccessTokenForUser(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = getActiveAccessTokenForUser_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.success is not None:
3595 
      return result.success
3596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3597 
 
3598 
  def validateAccessToken(self, accessToken):
3599 
    """
3600 
    Parameters:
3601 
     - accessToken
3602 
    """
3603 
    self.send_validateAccessToken(accessToken)
3604 
    return self.recv_validateAccessToken()
3605 
 
3606 
  def send_validateAccessToken(self, accessToken):
3607 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3608 
    args = validateAccessToken_args()
3609 
    args.accessToken = accessToken
3610 
    args.write(self._oprot)
3611 
    self._oprot.writeMessageEnd()
3612 
    self._oprot.trans.flush()
3613 
 
3614 
  def recv_validateAccessToken(self, ):
3615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3616 
    if mtype == TMessageType.EXCEPTION:
3617 
      x = TApplicationException()
3618 
      x.read(self._iprot)
3619 
      self._iprot.readMessageEnd()
3620 
      raise x
3621 
    result = validateAccessToken_result()
3622 
    result.read(self._iprot)
3623 
    self._iprot.readMessageEnd()
3624 
    if result.success is not None:
3625 
      return result.success
3626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3627 
 
17782 amit.gupta 3628 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3629 
    """
3630 
    Parameters:
3631 
     - cartId
3632 
     - itemQty
3633 
     - couponCode
3634 
    """
3635 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3636 
    return self.recv_addItemsToCart()
15251 manish.sha 3637 
 
17782 amit.gupta 3638 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3639 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3640 
    args = addItemsToCart_args()
3641 
    args.cartId = cartId
3642 
    args.itemQty = itemQty
3643 
    args.couponCode = couponCode
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_addItemsToCart(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = addItemsToCart_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3658 
    if result.success is not None:
3659 
      return result.success
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3661 
 
3662 
  def validateCartNew(self, cartId, pinCode, sourceId):
3663 
    """
3664 
    Parameters:
3665 
     - cartId
3666 
     - pinCode
3667 
     - sourceId
3668 
    """
3669 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3670 
    return self.recv_validateCartNew()
3671 
 
3672 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3673 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3674 
    args = validateCartNew_args()
3675 
    args.cartId = cartId
3676 
    args.pinCode = pinCode
3677 
    args.sourceId = sourceId
3678 
    args.write(self._oprot)
3679 
    self._oprot.writeMessageEnd()
3680 
    self._oprot.trans.flush()
3681 
 
3682 
  def recv_validateCartNew(self, ):
3683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3684 
    if mtype == TMessageType.EXCEPTION:
3685 
      x = TApplicationException()
3686 
      x.read(self._iprot)
3687 
      self._iprot.readMessageEnd()
3688 
      raise x
3689 
    result = validateCartNew_result()
3690 
    result.read(self._iprot)
3691 
    self._iprot.readMessageEnd()
3692 
    if result.success is not None:
3693 
      return result.success
3694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3695 
 
18644 manish.sha 3696 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3697 
    """
3698 
    Parameters:
3699 
     - userId
3700 
    """
18644 manish.sha 3701 
    self.send_isAddressEditableForCounter(userId)
3702 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3703 
 
18644 manish.sha 3704 
  def send_isAddressEditableForCounter(self, userId):
3705 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3706 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3707 
    args.userId = userId
3708 
    args.write(self._oprot)
3709 
    self._oprot.writeMessageEnd()
3710 
    self._oprot.trans.flush()
3711 
 
18644 manish.sha 3712 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3714 
    if mtype == TMessageType.EXCEPTION:
3715 
      x = TApplicationException()
3716 
      x.read(self._iprot)
3717 
      self._iprot.readMessageEnd()
3718 
      raise x
18644 manish.sha 3719 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3720 
    result.read(self._iprot)
3721 
    self._iprot.readMessageEnd()
3722 
    if result.success is not None:
3723 
      return result.success
18644 manish.sha 3724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3725 
 
3726 
  def getBillingAddressForUser(self, userId):
3727 
    """
3728 
    Parameters:
3729 
     - userId
3730 
    """
3731 
    self.send_getBillingAddressForUser(userId)
3732 
    return self.recv_getBillingAddressForUser()
3733 
 
3734 
  def send_getBillingAddressForUser(self, userId):
3735 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3736 
    args = getBillingAddressForUser_args()
3737 
    args.userId = userId
3738 
    args.write(self._oprot)
3739 
    self._oprot.writeMessageEnd()
3740 
    self._oprot.trans.flush()
3741 
 
3742 
  def recv_getBillingAddressForUser(self, ):
3743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3744 
    if mtype == TMessageType.EXCEPTION:
3745 
      x = TApplicationException()
3746 
      x.read(self._iprot)
3747 
      self._iprot.readMessageEnd()
3748 
      raise x
3749 
    result = getBillingAddressForUser_result()
3750 
    result.read(self._iprot)
3751 
    self._iprot.readMessageEnd()
3752 
    if result.success is not None:
3753 
      return result.success
3754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3755 
 
18590 manish.sha 3756 
  def isCreditorAssigned(self, userId):
3757 
    """
3758 
    Parameters:
3759 
     - userId
3760 
    """
3761 
    self.send_isCreditorAssigned(userId)
3762 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3763 
 
18590 manish.sha 3764 
  def send_isCreditorAssigned(self, userId):
3765 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3766 
    args = isCreditorAssigned_args()
3767 
    args.userId = userId
3768 
    args.write(self._oprot)
3769 
    self._oprot.writeMessageEnd()
3770 
    self._oprot.trans.flush()
3771 
 
3772 
  def recv_isCreditorAssigned(self, ):
3773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3774 
    if mtype == TMessageType.EXCEPTION:
3775 
      x = TApplicationException()
3776 
      x.read(self._iprot)
3777 
      self._iprot.readMessageEnd()
3778 
      raise x
3779 
    result = isCreditorAssigned_result()
3780 
    result.read(self._iprot)
3781 
    self._iprot.readMessageEnd()
3782 
    if result.success is not None:
3783 
      return result.success
3784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3785 
 
18735 manish.sha 3786 
  def isTaxInvoiceEnabledUser(self, userId):
3787 
    """
3788 
    Parameters:
3789 
     - userId
3790 
    """
3791 
    self.send_isTaxInvoiceEnabledUser(userId)
3792 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3793 
 
18735 manish.sha 3794 
  def send_isTaxInvoiceEnabledUser(self, userId):
3795 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3796 
    args = isTaxInvoiceEnabledUser_args()
3797 
    args.userId = userId
3798 
    args.write(self._oprot)
3799 
    self._oprot.writeMessageEnd()
3800 
    self._oprot.trans.flush()
3801 
 
3802 
  def recv_isTaxInvoiceEnabledUser(self, ):
3803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3804 
    if mtype == TMessageType.EXCEPTION:
3805 
      x = TApplicationException()
3806 
      x.read(self._iprot)
3807 
      self._iprot.readMessageEnd()
3808 
      raise x
3809 
    result = isTaxInvoiceEnabledUser_result()
3810 
    result.read(self._iprot)
3811 
    self._iprot.readMessageEnd()
3812 
    if result.success is not None:
3813 
      return result.success
3814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3815 
 
19182 amit.gupta 3816 
  def taxInvoiceAvailable(self, addressId):
3817 
    """
3818 
    Parameters:
3819 
     - addressId
3820 
    """
3821 
    self.send_taxInvoiceAvailable(addressId)
3822 
    return self.recv_taxInvoiceAvailable()
3823 
 
3824 
  def send_taxInvoiceAvailable(self, addressId):
3825 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3826 
    args = taxInvoiceAvailable_args()
3827 
    args.addressId = addressId
3828 
    args.write(self._oprot)
3829 
    self._oprot.writeMessageEnd()
3830 
    self._oprot.trans.flush()
3831 
 
3832 
  def recv_taxInvoiceAvailable(self, ):
3833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3834 
    if mtype == TMessageType.EXCEPTION:
3835 
      x = TApplicationException()
3836 
      x.read(self._iprot)
3837 
      self._iprot.readMessageEnd()
3838 
      raise x
3839 
    result = taxInvoiceAvailable_result()
3840 
    result.read(self._iprot)
3841 
    self._iprot.readMessageEnd()
3842 
    if result.success is not None:
3843 
      return result.success
3844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3845 
 
18764 kshitij.so 3846 
  def getCartByValue(self, cartIds):
3847 
    """
3848 
    Parameters:
3849 
     - cartIds
3850 
    """
3851 
    self.send_getCartByValue(cartIds)
3852 
    return self.recv_getCartByValue()
18735 manish.sha 3853 
 
18764 kshitij.so 3854 
  def send_getCartByValue(self, cartIds):
3855 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3856 
    args = getCartByValue_args()
3857 
    args.cartIds = cartIds
3858 
    args.write(self._oprot)
3859 
    self._oprot.writeMessageEnd()
3860 
    self._oprot.trans.flush()
3861 
 
3862 
  def recv_getCartByValue(self, ):
3863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3864 
    if mtype == TMessageType.EXCEPTION:
3865 
      x = TApplicationException()
3866 
      x.read(self._iprot)
3867 
      self._iprot.readMessageEnd()
3868 
      raise x
3869 
    result = getCartByValue_result()
3870 
    result.read(self._iprot)
3871 
    self._iprot.readMessageEnd()
3872 
    if result.success is not None:
3873 
      return result.success
3874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3875 
 
19889 manas 3876 
  def getCounterName(self, userIds):
3877 
    """
3878 
    Parameters:
3879 
     - userIds
3880 
    """
3881 
    self.send_getCounterName(userIds)
3882 
    return self.recv_getCounterName()
18764 kshitij.so 3883 
 
19889 manas 3884 
  def send_getCounterName(self, userIds):
3885 
    self._oprot.writeMessageBegin('getCounterName', TMessageType.CALL, self._seqid)
3886 
    args = getCounterName_args()
3887 
    args.userIds = userIds
3888 
    args.write(self._oprot)
3889 
    self._oprot.writeMessageEnd()
3890 
    self._oprot.trans.flush()
3891 
 
3892 
  def recv_getCounterName(self, ):
3893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3894 
    if mtype == TMessageType.EXCEPTION:
3895 
      x = TApplicationException()
3896 
      x.read(self._iprot)
3897 
      self._iprot.readMessageEnd()
3898 
      raise x
3899 
    result = getCounterName_result()
3900 
    result.read(self._iprot)
3901 
    self._iprot.readMessageEnd()
3902 
    if result.success is not None:
3903 
      return result.success
3904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterName failed: unknown result");
3905 
 
20873 kshitij.so 3906 
  def setWalletAmountInCart(self, cartId, wallet_amount):
3907 
    """
3908 
    Parameters:
3909 
     - cartId
3910 
     - wallet_amount
3911 
    """
3912 
    self.send_setWalletAmountInCart(cartId, wallet_amount)
3913 
    return self.recv_setWalletAmountInCart()
19889 manas 3914 
 
20873 kshitij.so 3915 
  def send_setWalletAmountInCart(self, cartId, wallet_amount):
3916 
    self._oprot.writeMessageBegin('setWalletAmountInCart', TMessageType.CALL, self._seqid)
3917 
    args = setWalletAmountInCart_args()
3918 
    args.cartId = cartId
3919 
    args.wallet_amount = wallet_amount
3920 
    args.write(self._oprot)
3921 
    self._oprot.writeMessageEnd()
3922 
    self._oprot.trans.flush()
3923 
 
3924 
  def recv_setWalletAmountInCart(self, ):
3925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3926 
    if mtype == TMessageType.EXCEPTION:
3927 
      x = TApplicationException()
3928 
      x.read(self._iprot)
3929 
      self._iprot.readMessageEnd()
3930 
      raise x
3931 
    result = setWalletAmountInCart_result()
3932 
    result.read(self._iprot)
3933 
    self._iprot.readMessageEnd()
3934 
    if result.success is not None:
3935 
      return result.success
3936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setWalletAmountInCart failed: unknown result");
3937 
 
3938 
 
3376 rajveer 3939 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3940 
  def __init__(self, handler):
3376 rajveer 3941 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3942 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3943 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3944 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3945 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3946 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3947 
    self._processMap["createUser"] = Processor.process_createUser
3948 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3949 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3950 
    self._processMap["userExists"] = Processor.process_userExists
3951 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3952 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3953 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3954 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3955 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3956 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3957 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3958 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3959 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3960 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3961 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3962 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3963 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3964 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3965 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3966 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3967 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3968 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3969 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3970 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3971 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3972 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3973 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3974 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3975 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3976 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3977 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3978 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3979 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3980 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3981 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3982 
    self._processMap["getCart"] = Processor.process_getCart
3983 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3984 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3985 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3986 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3987 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3988 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3989 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3990 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3991 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3992 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3993 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3994 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3995 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3996 
    self._processMap["checkOut"] = Processor.process_checkOut
3997 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3998 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3999 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 4000 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
4001 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
4002 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
4003 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
4004 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 4005 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 4006 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 4007 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 4008 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 4009 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 4010 
    self._processMap["insureItem"] = Processor.process_insureItem
4011 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
4012 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
4013 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 4014 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 4015 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 4016 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 4017 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
4018 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
4019 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 4020 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 4021 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 4022 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 4023 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 4024 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
4025 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 4026 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
4027 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 4028 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 4029 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 4030 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 4031 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 4032 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 4033 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
19889 manas 4034 
    self._processMap["getCounterName"] = Processor.process_getCounterName
20873 kshitij.so 4035 
    self._processMap["setWalletAmountInCart"] = Processor.process_setWalletAmountInCart
94 ashish 4036 
 
4037 
  def process(self, iprot, oprot):
4038 
    (name, type, seqid) = iprot.readMessageBegin()
4039 
    if name not in self._processMap:
4040 
      iprot.skip(TType.STRUCT)
4041 
      iprot.readMessageEnd()
4042 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4043 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4044 
      x.write(oprot)
4045 
      oprot.writeMessageEnd()
4046 
      oprot.trans.flush()
4047 
      return
4048 
    else:
4049 
      self._processMap[name](self, seqid, iprot, oprot)
4050 
    return True
4051 
 
559 chandransh 4052 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
4053 
    args = createAnonymousUser_args()
94 ashish 4054 
    args.read(iprot)
4055 
    iprot.readMessageEnd()
559 chandransh 4056 
    result = createAnonymousUser_result()
94 ashish 4057 
    try:
559 chandransh 4058 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
4059 
    except UserContextException, ucex:
4060 
      result.ucex = ucex
4061 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 4062 
    result.write(oprot)
4063 
    oprot.writeMessageEnd()
4064 
    oprot.trans.flush()
4065 
 
559 chandransh 4066 
  def process_getUserById(self, seqid, iprot, oprot):
4067 
    args = getUserById_args()
94 ashish 4068 
    args.read(iprot)
4069 
    iprot.readMessageEnd()
559 chandransh 4070 
    result = getUserById_result()
94 ashish 4071 
    try:
559 chandransh 4072 
      result.success = self._handler.getUserById(args.userId)
4073 
    except UserContextException, ucex:
4074 
      result.ucex = ucex
4075 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 4076 
    result.write(oprot)
4077 
    oprot.writeMessageEnd()
4078 
    oprot.trans.flush()
4079 
 
5326 rajveer 4080 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4081 
    args = getUserByCartId_args()
4082 
    args.read(iprot)
4083 
    iprot.readMessageEnd()
4084 
    result = getUserByCartId_result()
4085 
    try:
4086 
      result.success = self._handler.getUserByCartId(args.cartId)
4087 
    except UserContextException, ucex:
4088 
      result.ucex = ucex
4089 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4090 
    result.write(oprot)
4091 
    oprot.writeMessageEnd()
4092 
    oprot.trans.flush()
4093 
 
1491 vikas 4094 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4095 
    args = getUserByEmail_args()
4096 
    args.read(iprot)
4097 
    iprot.readMessageEnd()
4098 
    result = getUserByEmail_result()
4099 
    try:
4100 
      result.success = self._handler.getUserByEmail(args.email)
4101 
    except UserContextException, ucex:
4102 
      result.ucex = ucex
4103 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4104 
    result.write(oprot)
4105 
    oprot.writeMessageEnd()
4106 
    oprot.trans.flush()
4107 
 
3032 mandeep.dh 4108 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4109 
    args = getUserByMobileNumber_args()
4110 
    args.read(iprot)
4111 
    iprot.readMessageEnd()
4112 
    result = getUserByMobileNumber_result()
4113 
    try:
4114 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4115 
    except UserContextException, ucex:
4116 
      result.ucex = ucex
4117 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
4121 
 
559 chandransh 4122 
  def process_createUser(self, seqid, iprot, oprot):
4123 
    args = createUser_args()
94 ashish 4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
559 chandransh 4126 
    result = createUser_result()
94 ashish 4127 
    try:
559 chandransh 4128 
      result.success = self._handler.createUser(args.user)
4129 
    except UserContextException, ucex:
4130 
      result.ucex = ucex
4131 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4132 
    result.write(oprot)
4133 
    oprot.writeMessageEnd()
4134 
    oprot.trans.flush()
4135 
 
559 chandransh 4136 
  def process_updateUser(self, seqid, iprot, oprot):
4137 
    args = updateUser_args()
94 ashish 4138 
    args.read(iprot)
4139 
    iprot.readMessageEnd()
559 chandransh 4140 
    result = updateUser_result()
94 ashish 4141 
    try:
559 chandransh 4142 
      result.success = self._handler.updateUser(args.user)
4143 
    except UserContextException, ucex:
4144 
      result.ucex = ucex
4145 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4146 
    result.write(oprot)
4147 
    oprot.writeMessageEnd()
4148 
    oprot.trans.flush()
4149 
 
122 ashish 4150 
  def process_authenticateUser(self, seqid, iprot, oprot):
4151 
    args = authenticateUser_args()
4152 
    args.read(iprot)
4153 
    iprot.readMessageEnd()
4154 
    result = authenticateUser_result()
4155 
    try:
559 chandransh 4156 
      result.success = self._handler.authenticateUser(args.email, args.password)
4157 
    except AuthenticationException, auex:
4158 
      result.auex = auex
122 ashish 4159 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4160 
    result.write(oprot)
4161 
    oprot.writeMessageEnd()
4162 
    oprot.trans.flush()
4163 
 
94 ashish 4164 
  def process_userExists(self, seqid, iprot, oprot):
4165 
    args = userExists_args()
4166 
    args.read(iprot)
4167 
    iprot.readMessageEnd()
4168 
    result = userExists_result()
4169 
    try:
4170 
      result.success = self._handler.userExists(args.email)
4171 
    except UserContextException, ucx:
4172 
      result.ucx = ucx
4173 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4174 
    result.write(oprot)
4175 
    oprot.writeMessageEnd()
4176 
    oprot.trans.flush()
4177 
 
4178 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4179 
    args = addAddressForUser_args()
4180 
    args.read(iprot)
4181 
    iprot.readMessageEnd()
4182 
    result = addAddressForUser_result()
4183 
    try:
567 rajveer 4184 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4185 
    except UserContextException, ucx:
4186 
      result.ucx = ucx
4187 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4188 
    result.write(oprot)
4189 
    oprot.writeMessageEnd()
4190 
    oprot.trans.flush()
4191 
 
4192 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4193 
    args = removeAddressForUser_args()
4194 
    args.read(iprot)
4195 
    iprot.readMessageEnd()
4196 
    result = removeAddressForUser_result()
4197 
    try:
4198 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4199 
    except UserContextException, ucx:
4200 
      result.ucx = ucx
4201 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
4206 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4207 
    args = setUserAsLoggedIn_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = setUserAsLoggedIn_result()
4211 
    try:
4212 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4213 
    except UserContextException, ucx:
4214 
      result.ucx = ucx
4215 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4216 
    result.write(oprot)
4217 
    oprot.writeMessageEnd()
4218 
    oprot.trans.flush()
4219 
 
4220 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4221 
    args = setUserAsLoggedOut_args()
4222 
    args.read(iprot)
4223 
    iprot.readMessageEnd()
4224 
    result = setUserAsLoggedOut_result()
4225 
    try:
4226 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4227 
    except UserContextException, ucx:
4228 
      result.ucx = ucx
4229 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4233 
 
504 rajveer 4234 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4235 
    args = setDefaultAddress_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = setDefaultAddress_result()
4239 
    try:
4240 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4241 
    except UserContextException, ucx:
4242 
      result.ucx = ucx
4243 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
4247 
 
94 ashish 4248 
  def process_updatePassword(self, seqid, iprot, oprot):
4249 
    args = updatePassword_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = updatePassword_result()
4253 
    try:
594 rajveer 4254 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4255 
    except UserContextException, ucx:
4256 
      result.ucx = ucx
4257 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4261 
 
581 rajveer 4262 
  def process_forgotPassword(self, seqid, iprot, oprot):
4263 
    args = forgotPassword_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = forgotPassword_result()
4267 
    try:
884 rajveer 4268 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4269 
    except UserContextException, ucx:
4270 
      result.ucx = ucx
4271 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
594 rajveer 4276 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4277 
    args = getAllAddressesForUser_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = getAllAddressesForUser_result()
4281 
    try:
4282 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4283 
    except UserContextException, ucx:
4284 
      result.ucx = ucx
4285 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
4289 
 
1894 vikas 4290 
  def process_getAddressById(self, seqid, iprot, oprot):
4291 
    args = getAddressById_args()
4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4294 
    result = getAddressById_result()
4295 
    try:
4296 
      result.success = self._handler.getAddressById(args.addressId)
4297 
    except UserContextException, ucx:
4298 
      result.ucx = ucx
4299 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
4303 
 
594 rajveer 4304 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4305 
    args = getDefaultAddressId_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = getDefaultAddressId_result()
4309 
    try:
4310 
      result.success = self._handler.getDefaultAddressId(args.userId)
4311 
    except UserContextException, ucx:
4312 
      result.ucx = ucx
4313 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4314 
    result.write(oprot)
4315 
    oprot.writeMessageEnd()
4316 
    oprot.trans.flush()
4317 
 
785 rajveer 4318 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4319 
    args = getDefaultPincode_args()
4320 
    args.read(iprot)
4321 
    iprot.readMessageEnd()
4322 
    result = getDefaultPincode_result()
4323 
    try:
4324 
      result.success = self._handler.getDefaultPincode(args.userId)
4325 
    except UserContextException, ucx:
4326 
      result.ucx = ucx
4327 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
4331 
 
1274 varun.gupt 4332 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4333 
    args = saveUserCommunication_args()
4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
4336 
    result = saveUserCommunication_result()
4337 
    try:
4338 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4339 
    except UserCommunicationException, ucx:
4340 
      result.ucx = ucx
4341 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
4345 
 
1590 varun.gupt 4346 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4347 
    args = getUserCommunicationById_args()
4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
4350 
    result = getUserCommunicationById_result()
4351 
    try:
4352 
      result.success = self._handler.getUserCommunicationById(args.id)
4353 
    except UserCommunicationException, ucx:
4354 
      result.ucx = ucx
4355 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
4360 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4361 
    args = getUserCommunicationByUser_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = getUserCommunicationByUser_result()
4365 
    try:
4366 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4367 
    except UserCommunicationException, ucx:
4368 
      result.ucx = ucx
4369 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4375 
    args = getAllUserCommunications_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = getAllUserCommunications_result()
4379 
    try:
4380 
      result.success = self._handler.getAllUserCommunications()
4381 
    except UserCommunicationException, ucx:
4382 
      result.ucx = ucx
4383 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4384 
    result.write(oprot)
4385 
    oprot.writeMessageEnd()
4386 
    oprot.trans.flush()
4387 
 
5407 amar.kumar 4388 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4389 
    args = removeUserCommunication_args()
4390 
    args.read(iprot)
4391 
    iprot.readMessageEnd()
4392 
    result = removeUserCommunication_result()
4393 
    try:
4394 
      self._handler.removeUserCommunication(args.id)
4395 
    except UserCommunicationException, ucx:
4396 
      result.ucx = ucx
4397 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
4401 
 
1845 vikas 4402 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4403 
    args = createMasterAffiliate_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = createMasterAffiliate_result()
4407 
    try:
1859 vikas 4408 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4409 
    except UserAffiliateException, utx:
1845 vikas 4410 
      result.utx = utx
4411 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4412 
    result.write(oprot)
4413 
    oprot.writeMessageEnd()
4414 
    oprot.trans.flush()
4415 
 
1899 vikas 4416 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4417 
    args = getAllMasterAffiliates_args()
4418 
    args.read(iprot)
4419 
    iprot.readMessageEnd()
4420 
    result = getAllMasterAffiliates_result()
4421 
    try:
4422 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4423 
    except UserAffiliateException, utx:
1899 vikas 4424 
      result.utx = utx
4425 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4426 
    result.write(oprot)
4427 
    oprot.writeMessageEnd()
4428 
    oprot.trans.flush()
4429 
 
1845 vikas 4430 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4431 
    args = getMasterAffiliateById_args()
4432 
    args.read(iprot)
4433 
    iprot.readMessageEnd()
4434 
    result = getMasterAffiliateById_result()
4435 
    try:
4436 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4437 
    except UserAffiliateException, utx:
1845 vikas 4438 
      result.utx = utx
4439 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
4443 
 
4444 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4445 
    args = getMasterAffiliateByName_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getMasterAffiliateByName_result()
4449 
    try:
4450 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4451 
    except UserAffiliateException, utx:
1845 vikas 4452 
      result.utx = utx
4453 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4454 
    result.write(oprot)
4455 
    oprot.writeMessageEnd()
4456 
    oprot.trans.flush()
4457 
 
4458 
  def process_createAffiliate(self, seqid, iprot, oprot):
4459 
    args = createAffiliate_args()
4460 
    args.read(iprot)
4461 
    iprot.readMessageEnd()
4462 
    result = createAffiliate_result()
4463 
    try:
1859 vikas 4464 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4465 
    except UserAffiliateException, utx:
1845 vikas 4466 
      result.utx = utx
4467 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4468 
    result.write(oprot)
4469 
    oprot.writeMessageEnd()
4470 
    oprot.trans.flush()
4471 
 
4472 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4473 
    args = getAffiliateById_args()
4474 
    args.read(iprot)
4475 
    iprot.readMessageEnd()
4476 
    result = getAffiliateById_result()
4477 
    try:
4478 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4479 
    except UserAffiliateException, utx:
1845 vikas 4480 
      result.utx = utx
4481 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4482 
    result.write(oprot)
4483 
    oprot.writeMessageEnd()
4484 
    oprot.trans.flush()
4485 
 
4486 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4487 
    args = getAffiliateByName_args()
4488 
    args.read(iprot)
4489 
    iprot.readMessageEnd()
4490 
    result = getAffiliateByName_result()
4491 
    try:
4492 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4493 
    except UserAffiliateException, utx:
1845 vikas 4494 
      result.utx = utx
4495 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4496 
    result.write(oprot)
4497 
    oprot.writeMessageEnd()
4498 
    oprot.trans.flush()
4499 
 
4500 
  def process_getTrackerById(self, seqid, iprot, oprot):
4501 
    args = getTrackerById_args()
4502 
    args.read(iprot)
4503 
    iprot.readMessageEnd()
4504 
    result = getTrackerById_result()
4505 
    try:
1996 vikas 4506 
      result.success = self._handler.getTrackerById(args.id)
4507 
    except UserAffiliateException, utx:
1845 vikas 4508 
      result.utx = utx
4509 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4510 
    result.write(oprot)
4511 
    oprot.writeMessageEnd()
4512 
    oprot.trans.flush()
4513 
 
1996 vikas 4514 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4515 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4516 
    args.read(iprot)
4517 
    iprot.readMessageEnd()
1996 vikas 4518 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4519 
    try:
1996 vikas 4520 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4521 
    except UserAffiliateException, utx:
1845 vikas 4522 
      result.utx = utx
1996 vikas 4523 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4524 
    result.write(oprot)
4525 
    oprot.writeMessageEnd()
4526 
    oprot.trans.flush()
4527 
 
4528 
  def process_addTrackLog(self, seqid, iprot, oprot):
4529 
    args = addTrackLog_args()
4530 
    args.read(iprot)
4531 
    iprot.readMessageEnd()
4532 
    result = addTrackLog_result()
4533 
    try:
1996 vikas 4534 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4535 
    except UserAffiliateException, utx:
1845 vikas 4536 
      result.utx = utx
4537 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
4542 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4543 
    args = getTrackLogById_args()
4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
4546 
    result = getTrackLogById_result()
4547 
    try:
4548 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4549 
    except UserAffiliateException, utx:
1845 vikas 4550 
      result.utx = utx
4551 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4552 
    result.write(oprot)
4553 
    oprot.writeMessageEnd()
4554 
    oprot.trans.flush()
4555 
 
1996 vikas 4556 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4557 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4558 
    args.read(iprot)
4559 
    iprot.readMessageEnd()
1996 vikas 4560 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4561 
    try:
3293 vikas 4562 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4563 
    except UserAffiliateException, utx:
1845 vikas 4564 
      result.utx = utx
1996 vikas 4565 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4566 
    result.write(oprot)
4567 
    oprot.writeMessageEnd()
4568 
    oprot.trans.flush()
4569 
 
4570 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4571 
    args = getTrackLogsByUser_args()
4572 
    args.read(iprot)
4573 
    iprot.readMessageEnd()
4574 
    result = getTrackLogsByUser_result()
4575 
    try:
4576 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4577 
    except UserAffiliateException, utx:
1845 vikas 4578 
      result.utx = utx
4579 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4580 
    result.write(oprot)
4581 
    oprot.writeMessageEnd()
4582 
    oprot.trans.flush()
4583 
 
4584 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4585 
    args = getTrackLogs_args()
4586 
    args.read(iprot)
4587 
    iprot.readMessageEnd()
4588 
    result = getTrackLogs_result()
4589 
    try:
1996 vikas 4590 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4591 
    except UserAffiliateException, utx:
1845 vikas 4592 
      result.utx = utx
4593 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4594 
    result.write(oprot)
4595 
    oprot.writeMessageEnd()
4596 
    oprot.trans.flush()
4597 
 
559 chandransh 4598 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4599 
    args = getCurrentCart_args()
94 ashish 4600 
    args.read(iprot)
4601 
    iprot.readMessageEnd()
559 chandransh 4602 
    result = getCurrentCart_result()
94 ashish 4603 
    try:
559 chandransh 4604 
      result.success = self._handler.getCurrentCart(args.userId)
4605 
    except ShoppingCartException, scx:
4606 
      result.scx = scx
4607 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4608 
    result.write(oprot)
4609 
    oprot.writeMessageEnd()
4610 
    oprot.trans.flush()
4611 
 
559 chandransh 4612 
  def process_getCart(self, seqid, iprot, oprot):
4613 
    args = getCart_args()
94 ashish 4614 
    args.read(iprot)
4615 
    iprot.readMessageEnd()
559 chandransh 4616 
    result = getCart_result()
94 ashish 4617 
    try:
559 chandransh 4618 
      result.success = self._handler.getCart(args.cartId)
4619 
    except ShoppingCartException, scx:
4620 
      result.scx = scx
4621 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4622 
    result.write(oprot)
4623 
    oprot.writeMessageEnd()
4624 
    oprot.trans.flush()
4625 
 
559 chandransh 4626 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4627 
    args = getCartsByTime_args()
94 ashish 4628 
    args.read(iprot)
4629 
    iprot.readMessageEnd()
559 chandransh 4630 
    result = getCartsByTime_result()
94 ashish 4631 
    try:
559 chandransh 4632 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4633 
    except ShoppingCartException, scx:
4634 
      result.scx = scx
4635 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4636 
    result.write(oprot)
4637 
    oprot.writeMessageEnd()
4638 
    oprot.trans.flush()
4639 
 
559 chandransh 4640 
  def process_addItemToCart(self, seqid, iprot, oprot):
4641 
    args = addItemToCart_args()
130 ashish 4642 
    args.read(iprot)
4643 
    iprot.readMessageEnd()
559 chandransh 4644 
    result = addItemToCart_result()
130 ashish 4645 
    try:
3557 rajveer 4646 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4647 
    except ShoppingCartException, scx:
4648 
      result.scx = scx
4649 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4650 
    result.write(oprot)
4651 
    oprot.writeMessageEnd()
4652 
    oprot.trans.flush()
4653 
 
559 chandransh 4654 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4655 
    args = deleteItemFromCart_args()
4656 
    args.read(iprot)
4657 
    iprot.readMessageEnd()
4658 
    result = deleteItemFromCart_result()
4659 
    try:
4660 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4661 
    except ShoppingCartException, scx:
4662 
      result.scx = scx
4663 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4664 
    result.write(oprot)
4665 
    oprot.writeMessageEnd()
4666 
    oprot.trans.flush()
130 ashish 4667 
 
559 chandransh 4668 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4669 
    args = addAddressToCart_args()
4670 
    args.read(iprot)
4671 
    iprot.readMessageEnd()
4672 
    result = addAddressToCart_result()
575 chandransh 4673 
    try:
4674 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4675 
    except ShoppingCartException, scx:
4676 
      result.scx = scx
559 chandransh 4677 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4678 
    result.write(oprot)
4679 
    oprot.writeMessageEnd()
4680 
    oprot.trans.flush()
4681 
 
5553 rajveer 4682 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4683 
    args = addStoreToCart_args()
4684 
    args.read(iprot)
4685 
    iprot.readMessageEnd()
4686 
    result = addStoreToCart_result()
4687 
    try:
4688 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4689 
    except ShoppingCartException, scx:
4690 
      result.scx = scx
4691 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4692 
    result.write(oprot)
4693 
    oprot.writeMessageEnd()
4694 
    oprot.trans.flush()
4695 
 
1976 varun.gupt 4696 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4697 
    args = applyCouponToCart_args()
4698 
    args.read(iprot)
4699 
    iprot.readMessageEnd()
4700 
    result = applyCouponToCart_result()
4701 
    try:
6922 anupam.sin 4702 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4703 
    except ShoppingCartException, scx:
4704 
      result.scx = scx
4705 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4706 
    result.write(oprot)
4707 
    oprot.writeMessageEnd()
4708 
    oprot.trans.flush()
4709 
 
4710 
  def process_removeCoupon(self, seqid, iprot, oprot):
4711 
    args = removeCoupon_args()
4712 
    args.read(iprot)
4713 
    iprot.readMessageEnd()
4714 
    result = removeCoupon_result()
4715 
    try:
4716 
      self._handler.removeCoupon(args.cartId)
4717 
    except ShoppingCartException, scx:
4718 
      result.scx = scx
4719 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4720 
    result.write(oprot)
4721 
    oprot.writeMessageEnd()
4722 
    oprot.trans.flush()
4723 
 
3554 varun.gupt 4724 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4725 
    args = deleteDiscountsFromCart_args()
4726 
    args.read(iprot)
4727 
    iprot.readMessageEnd()
4728 
    result = deleteDiscountsFromCart_result()
4729 
    try:
4730 
      self._handler.deleteDiscountsFromCart(args.cartId)
4731 
    except ShoppingCartException, scx:
4732 
      result.scx = scx
4733 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4734 
    result.write(oprot)
4735 
    oprot.writeMessageEnd()
4736 
    oprot.trans.flush()
4737 
 
4738 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4739 
    args = saveDiscounts_args()
4740 
    args.read(iprot)
4741 
    iprot.readMessageEnd()
4742 
    result = saveDiscounts_result()
4743 
    try:
4744 
      self._handler.saveDiscounts(args.discounts)
4745 
    except ShoppingCartException, scx:
4746 
      result.scx = scx
4747 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4748 
    result.write(oprot)
4749 
    oprot.writeMessageEnd()
4750 
    oprot.trans.flush()
4751 
 
690 chandransh 4752 
  def process_createOrders(self, seqid, iprot, oprot):
4753 
    args = createOrders_args()
559 chandransh 4754 
    args.read(iprot)
4755 
    iprot.readMessageEnd()
690 chandransh 4756 
    result = createOrders_result()
559 chandransh 4757 
    try:
11526 amit.gupta 4758 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4759 
    except ShoppingCartException, scx:
4760 
      result.scx = scx
690 chandransh 4761 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4762 
    result.write(oprot)
4763 
    oprot.writeMessageEnd()
4764 
    oprot.trans.flush()
4765 
 
4766 
  def process_validateCart(self, seqid, iprot, oprot):
4767 
    args = validateCart_args()
4768 
    args.read(iprot)
4769 
    iprot.readMessageEnd()
4770 
    result = validateCart_result()
575 chandransh 4771 
    try:
3557 rajveer 4772 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4773 
    except ShoppingCartException, scex:
4774 
      result.scex = scex
559 chandransh 4775 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4776 
    result.write(oprot)
4777 
    oprot.writeMessageEnd()
4778 
    oprot.trans.flush()
4779 
 
11980 amit.gupta 4780 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4781 
    args = validateCartWithDealerCoupon_args()
4782 
    args.read(iprot)
4783 
    iprot.readMessageEnd()
4784 
    result = validateCartWithDealerCoupon_result()
4785 
    try:
4786 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4787 
    except ShoppingCartException, scex:
4788 
      result.scex = scex
4789 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4790 
    result.write(oprot)
4791 
    oprot.writeMessageEnd()
4792 
    oprot.trans.flush()
4793 
 
690 chandransh 4794 
  def process_mergeCart(self, seqid, iprot, oprot):
4795 
    args = mergeCart_args()
575 chandransh 4796 
    args.read(iprot)
4797 
    iprot.readMessageEnd()
690 chandransh 4798 
    result = mergeCart_result()
4799 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4800 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4801 
    result.write(oprot)
4802 
    oprot.writeMessageEnd()
4803 
    oprot.trans.flush()
4804 
 
4805 
  def process_checkOut(self, seqid, iprot, oprot):
4806 
    args = checkOut_args()
4807 
    args.read(iprot)
4808 
    iprot.readMessageEnd()
4809 
    result = checkOut_result()
575 chandransh 4810 
    try:
690 chandransh 4811 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4812 
    except ShoppingCartException, scex:
4813 
      result.scex = scex
690 chandransh 4814 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4815 
    result.write(oprot)
4816 
    oprot.writeMessageEnd()
4817 
    oprot.trans.flush()
4818 
 
690 chandransh 4819 
  def process_resetCart(self, seqid, iprot, oprot):
4820 
    args = resetCart_args()
559 chandransh 4821 
    args.read(iprot)
4822 
    iprot.readMessageEnd()
690 chandransh 4823 
    result = resetCart_result()
4824 
    try:
4825 
      result.success = self._handler.resetCart(args.cartId, args.items)
4826 
    except ShoppingCartException, scex:
4827 
      result.scex = scex
4828 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4829 
    result.write(oprot)
4830 
    oprot.writeMessageEnd()
4831 
    oprot.trans.flush()
4832 
 
2981 rajveer 4833 
  def process_getUserCount(self, seqid, iprot, oprot):
4834 
    args = getUserCount_args()
559 chandransh 4835 
    args.read(iprot)
4836 
    iprot.readMessageEnd()
2981 rajveer 4837 
    result = getUserCount_result()
4838 
    result.success = self._handler.getUserCount(args.userType)
4839 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4840 
    result.write(oprot)
4841 
    oprot.writeMessageEnd()
4842 
    oprot.trans.flush()
4843 
 
2981 rajveer 4844 
  def process_getAllUsers(self, seqid, iprot, oprot):
4845 
    args = getAllUsers_args()
559 chandransh 4846 
    args.read(iprot)
4847 
    iprot.readMessageEnd()
2981 rajveer 4848 
    result = getAllUsers_result()
4849 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4850 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4851 
    result.write(oprot)
4852 
    oprot.writeMessageEnd()
4853 
    oprot.trans.flush()
4854 
 
2981 rajveer 4855 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4856 
    args = getMyResearchItems_args()
559 chandransh 4857 
    args.read(iprot)
4858 
    iprot.readMessageEnd()
2981 rajveer 4859 
    result = getMyResearchItems_result()
559 chandransh 4860 
    try:
2981 rajveer 4861 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4862 
    except WidgetException, scx:
4863 
      result.scx = scx
2981 rajveer 4864 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4865 
    result.write(oprot)
4866 
    oprot.writeMessageEnd()
4867 
    oprot.trans.flush()
4868 
 
2981 rajveer 4869 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4870 
    args = updateMyResearch_args()
772 rajveer 4871 
    args.read(iprot)
4872 
    iprot.readMessageEnd()
2981 rajveer 4873 
    result = updateMyResearch_result()
4874 
    try:
4875 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4876 
    except WidgetException, scx:
4877 
      result.scx = scx
4878 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
559 chandransh 4882 
 
2981 rajveer 4883 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4884 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
2981 rajveer 4887 
    result = deleteItemFromMyResearch_result()
4888 
    try:
4889 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4890 
    except WidgetException, scx:
4891 
      result.scx = scx
4892 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4893 
    result.write(oprot)
4894 
    oprot.writeMessageEnd()
4895 
    oprot.trans.flush()
772 rajveer 4896 
 
2981 rajveer 4897 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4898 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4899 
    args.read(iprot)
4900 
    iprot.readMessageEnd()
2981 rajveer 4901 
    result = getBrowseHistoryItems_result()
4902 
    try:
4903 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4904 
    except WidgetException, scx:
4905 
      result.scx = scx
4906 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4907 
    result.write(oprot)
4908 
    oprot.writeMessageEnd()
4909 
    oprot.trans.flush()
1596 ankur.sing 4910 
 
2981 rajveer 4911 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4912 
    args = updateBrowseHistory_args()
2642 varun.gupt 4913 
    args.read(iprot)
4914 
    iprot.readMessageEnd()
2981 rajveer 4915 
    result = updateBrowseHistory_result()
4916 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4917 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
1673 ankur.sing 4921 
 
3385 varun.gupt 4922 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4923 
    args = getCartsWithCouponCount_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = getCartsWithCouponCount_result()
4927 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4928 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4929 
    result.write(oprot)
4930 
    oprot.writeMessageEnd()
4931 
    oprot.trans.flush()
2642 varun.gupt 4932 
 
3499 mandeep.dh 4933 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4934 
    args = increaseTrustLevel_args()
4935 
    args.read(iprot)
4936 
    iprot.readMessageEnd()
4937 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4938 
    return
3385 varun.gupt 4939 
 
5407 amar.kumar 4940 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4941 
    args = getTrustLevel_args()
4942 
    args.read(iprot)
4943 
    iprot.readMessageEnd()
4944 
    result = getTrustLevel_result()
4945 
    result.success = self._handler.getTrustLevel(args.userId)
4946 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
4668 varun.gupt 4951 
  def process_showCODOption(self, seqid, iprot, oprot):
4952 
    args = showCODOption_args()
4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
4955 
    result = showCODOption_result()
4956 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4957 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4958 
    result.write(oprot)
4959 
    oprot.writeMessageEnd()
4960 
    oprot.trans.flush()
3499 mandeep.dh 4961 
 
5623 anupam.sin 4962 
  def process_getUserEmails(self, seqid, iprot, oprot):
4963 
    args = getUserEmails_args()
4964 
    args.read(iprot)
4965 
    iprot.readMessageEnd()
4966 
    result = getUserEmails_result()
4967 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4968 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4969 
    result.write(oprot)
4970 
    oprot.writeMessageEnd()
4971 
    oprot.trans.flush()
4668 varun.gupt 4972 
 
6903 anupam.sin 4973 
  def process_insureItem(self, seqid, iprot, oprot):
4974 
    args = insureItem_args()
4975 
    args.read(iprot)
4976 
    iprot.readMessageEnd()
4977 
    result = insureItem_result()
9299 kshitij.so 4978 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4979 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4980 
    result.write(oprot)
4981 
    oprot.writeMessageEnd()
4982 
    oprot.trans.flush()
4983 
 
4984 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4985 
    args = cancelInsurance_args()
4986 
    args.read(iprot)
4987 
    iprot.readMessageEnd()
4988 
    result = cancelInsurance_result()
4989 
    result.success = self._handler.cancelInsurance(args.cartId)
4990 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4991 
    result.write(oprot)
4992 
    oprot.writeMessageEnd()
4993 
    oprot.trans.flush()
4994 
 
4995 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4996 
    args = storeInsuranceSpecificDetails_args()
4997 
    args.read(iprot)
4998 
    iprot.readMessageEnd()
4999 
    result = storeInsuranceSpecificDetails_result()
5000 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
5001 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
5002 
    result.write(oprot)
5003 
    oprot.writeMessageEnd()
5004 
    oprot.trans.flush()
5005 
 
5006 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
5007 
    args = isInsuranceDetailPresent_args()
5008 
    args.read(iprot)
5009 
    iprot.readMessageEnd()
5010 
    result = isInsuranceDetailPresent_result()
5011 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
5012 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
5013 
    result.write(oprot)
5014 
    oprot.writeMessageEnd()
5015 
    oprot.trans.flush()
5016 
 
9791 rajveer 5017 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
5018 
    args = getProductsAddedToCart_args()
6821 amar.kumar 5019 
    args.read(iprot)
5020 
    iprot.readMessageEnd()
9791 rajveer 5021 
    result = getProductsAddedToCart_result()
5022 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
5023 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 5024 
    result.write(oprot)
5025 
    oprot.writeMessageEnd()
5026 
    oprot.trans.flush()
5623 anupam.sin 5027 
 
11592 amit.gupta 5028 
  def process_validateCartPlus(self, seqid, iprot, oprot):
5029 
    args = validateCartPlus_args()
5030 
    args.read(iprot)
5031 
    iprot.readMessageEnd()
5032 
    result = validateCartPlus_result()
5033 
    try:
11980 amit.gupta 5034 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 5035 
    except ShoppingCartException, scex:
5036 
      result.scex = scex
5037 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
5038 
    result.write(oprot)
5039 
    oprot.writeMessageEnd()
5040 
    oprot.trans.flush()
6821 amar.kumar 5041 
 
11679 vikram.rag 5042 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
5043 
    args = isPrivateDealUser_args()
5044 
    args.read(iprot)
5045 
    iprot.readMessageEnd()
5046 
    result = isPrivateDealUser_result()
5047 
    result.success = self._handler.isPrivateDealUser(args.userId)
5048 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
5049 
    result.write(oprot)
5050 
    oprot.writeMessageEnd()
5051 
    oprot.trans.flush()
11592 amit.gupta 5052 
 
11890 kshitij.so 5053 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
5054 
    args = addPrivateDealUser_args()
5055 
    args.read(iprot)
5056 
    iprot.readMessageEnd()
5057 
    result = addPrivateDealUser_result()
5058 
    result.success = self._handler.addPrivateDealUser(args.userId)
5059 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
11679 vikram.rag 5063 
 
11890 kshitij.so 5064 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
5065 
    args = changePrivateDealUserStatus_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = changePrivateDealUserStatus_result()
5069 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
5070 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
5075 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
5076 
    args = getPrivateDealUser_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = getPrivateDealUser_result()
5080 
    result.success = self._handler.getPrivateDealUser(args.userId)
5081 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5082 
    result.write(oprot)
5083 
    oprot.writeMessageEnd()
5084 
    oprot.trans.flush()
5085 
 
12696 amit.gupta 5086 
  def process_registerCounter(self, seqid, iprot, oprot):
5087 
    args = registerCounter_args()
5088 
    args.read(iprot)
5089 
    iprot.readMessageEnd()
5090 
    result = registerCounter_result()
5091 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5092 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5093 
    result.write(oprot)
5094 
    oprot.writeMessageEnd()
5095 
    oprot.trans.flush()
11890 kshitij.so 5096 
 
12722 amit.gupta 5097 
  def process_searchCounter(self, seqid, iprot, oprot):
5098 
    args = searchCounter_args()
5099 
    args.read(iprot)
5100 
    iprot.readMessageEnd()
5101 
    result = searchCounter_result()
5102 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5103 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
12696 amit.gupta 5107 
 
18977 amit.gupta 5108 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5109 
    args = getCounterByUserId_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = getCounterByUserId_result()
5113 
    result.success = self._handler.getCounterByUserId(args.userId)
5114 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
5118 
 
12722 amit.gupta 5119 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5120 
    args = getAllUsersByCounter_args()
5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
5123 
    result = getAllUsersByCounter_result()
5124 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5125 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
15251 manish.sha 5130 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5131 
    args = getActiveAccessTokenForUser_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getActiveAccessTokenForUser_result()
5135 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5136 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5137 
    result.write(oprot)
5138 
    oprot.writeMessageEnd()
5139 
    oprot.trans.flush()
12722 amit.gupta 5140 
 
15251 manish.sha 5141 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5142 
    args = validateAccessToken_args()
5143 
    args.read(iprot)
5144 
    iprot.readMessageEnd()
5145 
    result = validateAccessToken_result()
5146 
    result.success = self._handler.validateAccessToken(args.accessToken)
5147 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
17782 amit.gupta 5152 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5153 
    args = addItemsToCart_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = addItemsToCart_result()
5157 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5158 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
15251 manish.sha 5162 
 
17782 amit.gupta 5163 
  def process_validateCartNew(self, seqid, iprot, oprot):
5164 
    args = validateCartNew_args()
5165 
    args.read(iprot)
5166 
    iprot.readMessageEnd()
5167 
    result = validateCartNew_result()
5168 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5169 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5170 
    result.write(oprot)
5171 
    oprot.writeMessageEnd()
5172 
    oprot.trans.flush()
5173 
 
18644 manish.sha 5174 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5175 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5176 
    args.read(iprot)
5177 
    iprot.readMessageEnd()
18644 manish.sha 5178 
    result = isAddressEditableForCounter_result()
5179 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5180 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5181 
    result.write(oprot)
5182 
    oprot.writeMessageEnd()
5183 
    oprot.trans.flush()
17782 amit.gupta 5184 
 
18530 manish.sha 5185 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5186 
    args = getBillingAddressForUser_args()
5187 
    args.read(iprot)
5188 
    iprot.readMessageEnd()
5189 
    result = getBillingAddressForUser_result()
5190 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5191 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5192 
    result.write(oprot)
5193 
    oprot.writeMessageEnd()
5194 
    oprot.trans.flush()
5195 
 
18590 manish.sha 5196 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5197 
    args = isCreditorAssigned_args()
5198 
    args.read(iprot)
5199 
    iprot.readMessageEnd()
5200 
    result = isCreditorAssigned_result()
5201 
    result.success = self._handler.isCreditorAssigned(args.userId)
5202 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5203 
    result.write(oprot)
5204 
    oprot.writeMessageEnd()
5205 
    oprot.trans.flush()
18530 manish.sha 5206 
 
18735 manish.sha 5207 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5208 
    args = isTaxInvoiceEnabledUser_args()
5209 
    args.read(iprot)
5210 
    iprot.readMessageEnd()
5211 
    result = isTaxInvoiceEnabledUser_result()
5212 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5213 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5214 
    result.write(oprot)
5215 
    oprot.writeMessageEnd()
5216 
    oprot.trans.flush()
18590 manish.sha 5217 
 
19182 amit.gupta 5218 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5219 
    args = taxInvoiceAvailable_args()
5220 
    args.read(iprot)
5221 
    iprot.readMessageEnd()
5222 
    result = taxInvoiceAvailable_result()
5223 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5224 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5225 
    result.write(oprot)
5226 
    oprot.writeMessageEnd()
5227 
    oprot.trans.flush()
5228 
 
18764 kshitij.so 5229 
  def process_getCartByValue(self, seqid, iprot, oprot):
5230 
    args = getCartByValue_args()
5231 
    args.read(iprot)
5232 
    iprot.readMessageEnd()
5233 
    result = getCartByValue_result()
5234 
    result.success = self._handler.getCartByValue(args.cartIds)
5235 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5236 
    result.write(oprot)
5237 
    oprot.writeMessageEnd()
5238 
    oprot.trans.flush()
18735 manish.sha 5239 
 
19889 manas 5240 
  def process_getCounterName(self, seqid, iprot, oprot):
5241 
    args = getCounterName_args()
5242 
    args.read(iprot)
5243 
    iprot.readMessageEnd()
5244 
    result = getCounterName_result()
5245 
    result.success = self._handler.getCounterName(args.userIds)
5246 
    oprot.writeMessageBegin("getCounterName", TMessageType.REPLY, seqid)
5247 
    result.write(oprot)
5248 
    oprot.writeMessageEnd()
5249 
    oprot.trans.flush()
18764 kshitij.so 5250 
 
20873 kshitij.so 5251 
  def process_setWalletAmountInCart(self, seqid, iprot, oprot):
5252 
    args = setWalletAmountInCart_args()
5253 
    args.read(iprot)
5254 
    iprot.readMessageEnd()
5255 
    result = setWalletAmountInCart_result()
5256 
    result.success = self._handler.setWalletAmountInCart(args.cartId, args.wallet_amount)
5257 
    oprot.writeMessageBegin("setWalletAmountInCart", TMessageType.REPLY, seqid)
5258 
    result.write(oprot)
5259 
    oprot.writeMessageEnd()
5260 
    oprot.trans.flush()
19889 manas 5261 
 
20873 kshitij.so 5262 
 
94 ashish 5263 
# HELPER FUNCTIONS AND STRUCTURES
5264 
 
559 chandransh 5265 
class createAnonymousUser_args:
94 ashish 5266 
  """
5267 
  Attributes:
559 chandransh 5268 
   - jsessionId
94 ashish 5269 
  """
5270 
 
5271 
  thrift_spec = (
5272 
    None, # 0
559 chandransh 5273 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5274 
  )
5275 
 
559 chandransh 5276 
  def __init__(self, jsessionId=None,):
5277 
    self.jsessionId = jsessionId
94 ashish 5278 
 
5279 
  def read(self, iprot):
5280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5282 
      return
5283 
    iprot.readStructBegin()
5284 
    while True:
5285 
      (fname, ftype, fid) = iprot.readFieldBegin()
5286 
      if ftype == TType.STOP:
5287 
        break
5288 
      if fid == 1:
559 chandransh 5289 
        if ftype == TType.STRING:
5290 
          self.jsessionId = iprot.readString();
94 ashish 5291 
        else:
5292 
          iprot.skip(ftype)
5293 
      else:
5294 
        iprot.skip(ftype)
5295 
      iprot.readFieldEnd()
5296 
    iprot.readStructEnd()
5297 
 
5298 
  def write(self, oprot):
5299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5301 
      return
559 chandransh 5302 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5303 
    if self.jsessionId is not None:
559 chandransh 5304 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5305 
      oprot.writeString(self.jsessionId)
94 ashish 5306 
      oprot.writeFieldEnd()
5307 
    oprot.writeFieldStop()
5308 
    oprot.writeStructEnd()
5309 
 
3431 rajveer 5310 
  def validate(self):
5311 
    return
5312 
 
5313 
 
94 ashish 5314 
  def __repr__(self):
5315 
    L = ['%s=%r' % (key, value)
5316 
      for key, value in self.__dict__.iteritems()]
5317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5318 
 
5319 
  def __eq__(self, other):
5320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5321 
 
5322 
  def __ne__(self, other):
5323 
    return not (self == other)
5324 
 
559 chandransh 5325 
class createAnonymousUser_result:
94 ashish 5326 
  """
5327 
  Attributes:
5328 
   - success
559 chandransh 5329 
   - ucex
94 ashish 5330 
  """
5331 
 
5332 
  thrift_spec = (
559 chandransh 5333 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5334 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5335 
  )
5336 
 
559 chandransh 5337 
  def __init__(self, success=None, ucex=None,):
94 ashish 5338 
    self.success = success
559 chandransh 5339 
    self.ucex = ucex
94 ashish 5340 
 
5341 
  def read(self, iprot):
5342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5344 
      return
5345 
    iprot.readStructBegin()
5346 
    while True:
5347 
      (fname, ftype, fid) = iprot.readFieldBegin()
5348 
      if ftype == TType.STOP:
5349 
        break
5350 
      if fid == 0:
5351 
        if ftype == TType.STRUCT:
559 chandransh 5352 
          self.success = User()
94 ashish 5353 
          self.success.read(iprot)
5354 
        else:
5355 
          iprot.skip(ftype)
5356 
      elif fid == 1:
5357 
        if ftype == TType.STRUCT:
559 chandransh 5358 
          self.ucex = UserContextException()
5359 
          self.ucex.read(iprot)
94 ashish 5360 
        else:
5361 
          iprot.skip(ftype)
5362 
      else:
5363 
        iprot.skip(ftype)
5364 
      iprot.readFieldEnd()
5365 
    iprot.readStructEnd()
5366 
 
5367 
  def write(self, oprot):
5368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5370 
      return
559 chandransh 5371 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5372 
    if self.success is not None:
94 ashish 5373 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5374 
      self.success.write(oprot)
5375 
      oprot.writeFieldEnd()
3431 rajveer 5376 
    if self.ucex is not None:
559 chandransh 5377 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5378 
      self.ucex.write(oprot)
94 ashish 5379 
      oprot.writeFieldEnd()
5380 
    oprot.writeFieldStop()
5381 
    oprot.writeStructEnd()
5382 
 
3431 rajveer 5383 
  def validate(self):
5384 
    return
5385 
 
5386 
 
94 ashish 5387 
  def __repr__(self):
5388 
    L = ['%s=%r' % (key, value)
5389 
      for key, value in self.__dict__.iteritems()]
5390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5391 
 
5392 
  def __eq__(self, other):
5393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5394 
 
5395 
  def __ne__(self, other):
5396 
    return not (self == other)
5397 
 
559 chandransh 5398 
class getUserById_args:
94 ashish 5399 
  """
5400 
  Attributes:
5401 
   - userId
5402 
  """
5403 
 
5404 
  thrift_spec = (
5405 
    None, # 0
5406 
    (1, TType.I64, 'userId', None, None, ), # 1
5407 
  )
5408 
 
559 chandransh 5409 
  def __init__(self, userId=None,):
94 ashish 5410 
    self.userId = userId
5411 
 
5412 
  def read(self, iprot):
5413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5415 
      return
5416 
    iprot.readStructBegin()
5417 
    while True:
5418 
      (fname, ftype, fid) = iprot.readFieldBegin()
5419 
      if ftype == TType.STOP:
5420 
        break
5421 
      if fid == 1:
5422 
        if ftype == TType.I64:
5423 
          self.userId = iprot.readI64();
5424 
        else:
5425 
          iprot.skip(ftype)
5426 
      else:
5427 
        iprot.skip(ftype)
5428 
      iprot.readFieldEnd()
5429 
    iprot.readStructEnd()
5430 
 
5431 
  def write(self, oprot):
5432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5434 
      return
559 chandransh 5435 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5436 
    if self.userId is not None:
94 ashish 5437 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5438 
      oprot.writeI64(self.userId)
5439 
      oprot.writeFieldEnd()
5440 
    oprot.writeFieldStop()
5441 
    oprot.writeStructEnd()
5442 
 
3431 rajveer 5443 
  def validate(self):
5444 
    return
5445 
 
5446 
 
94 ashish 5447 
  def __repr__(self):
5448 
    L = ['%s=%r' % (key, value)
5449 
      for key, value in self.__dict__.iteritems()]
5450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5451 
 
5452 
  def __eq__(self, other):
5453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5454 
 
5455 
  def __ne__(self, other):
5456 
    return not (self == other)
5457 
 
559 chandransh 5458 
class getUserById_result:
94 ashish 5459 
  """
5460 
  Attributes:
5461 
   - success
559 chandransh 5462 
   - ucex
94 ashish 5463 
  """
5464 
 
5465 
  thrift_spec = (
559 chandransh 5466 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5467 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5468 
  )
5469 
 
559 chandransh 5470 
  def __init__(self, success=None, ucex=None,):
94 ashish 5471 
    self.success = success
559 chandransh 5472 
    self.ucex = ucex
94 ashish 5473 
 
5474 
  def read(self, iprot):
5475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5477 
      return
5478 
    iprot.readStructBegin()
5479 
    while True:
5480 
      (fname, ftype, fid) = iprot.readFieldBegin()
5481 
      if ftype == TType.STOP:
5482 
        break
5483 
      if fid == 0:
5484 
        if ftype == TType.STRUCT:
559 chandransh 5485 
          self.success = User()
94 ashish 5486 
          self.success.read(iprot)
5487 
        else:
5488 
          iprot.skip(ftype)
5489 
      elif fid == 1:
5490 
        if ftype == TType.STRUCT:
559 chandransh 5491 
          self.ucex = UserContextException()
5492 
          self.ucex.read(iprot)
94 ashish 5493 
        else:
5494 
          iprot.skip(ftype)
5495 
      else:
5496 
        iprot.skip(ftype)
5497 
      iprot.readFieldEnd()
5498 
    iprot.readStructEnd()
5499 
 
5500 
  def write(self, oprot):
5501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5503 
      return
559 chandransh 5504 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5505 
    if self.success is not None:
94 ashish 5506 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5507 
      self.success.write(oprot)
5508 
      oprot.writeFieldEnd()
3431 rajveer 5509 
    if self.ucex is not None:
559 chandransh 5510 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5511 
      self.ucex.write(oprot)
94 ashish 5512 
      oprot.writeFieldEnd()
5513 
    oprot.writeFieldStop()
5514 
    oprot.writeStructEnd()
5515 
 
3431 rajveer 5516 
  def validate(self):
5517 
    return
5518 
 
5519 
 
94 ashish 5520 
  def __repr__(self):
5521 
    L = ['%s=%r' % (key, value)
5522 
      for key, value in self.__dict__.iteritems()]
5523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5524 
 
5525 
  def __eq__(self, other):
5526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5527 
 
5528 
  def __ne__(self, other):
5529 
    return not (self == other)
5530 
 
5326 rajveer 5531 
class getUserByCartId_args:
1491 vikas 5532 
  """
5533 
  Attributes:
5326 rajveer 5534 
   - cartId
1491 vikas 5535 
  """
5536 
 
5537 
  thrift_spec = (
5538 
    None, # 0
5326 rajveer 5539 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5540 
  )
5541 
 
5326 rajveer 5542 
  def __init__(self, cartId=None,):
5543 
    self.cartId = cartId
1491 vikas 5544 
 
5545 
  def read(self, iprot):
5546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5548 
      return
5549 
    iprot.readStructBegin()
5550 
    while True:
5551 
      (fname, ftype, fid) = iprot.readFieldBegin()
5552 
      if ftype == TType.STOP:
5553 
        break
5554 
      if fid == 1:
5326 rajveer 5555 
        if ftype == TType.I64:
5556 
          self.cartId = iprot.readI64();
1491 vikas 5557 
        else:
5558 
          iprot.skip(ftype)
5559 
      else:
5560 
        iprot.skip(ftype)
5561 
      iprot.readFieldEnd()
5562 
    iprot.readStructEnd()
5563 
 
5564 
  def write(self, oprot):
5565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5567 
      return
5326 rajveer 5568 
    oprot.writeStructBegin('getUserByCartId_args')
5569 
    if self.cartId is not None:
5570 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5571 
      oprot.writeI64(self.cartId)
1491 vikas 5572 
      oprot.writeFieldEnd()
5573 
    oprot.writeFieldStop()
5574 
    oprot.writeStructEnd()
5575 
 
3431 rajveer 5576 
  def validate(self):
5577 
    return
5578 
 
5579 
 
1491 vikas 5580 
  def __repr__(self):
5581 
    L = ['%s=%r' % (key, value)
5582 
      for key, value in self.__dict__.iteritems()]
5583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5584 
 
5585 
  def __eq__(self, other):
5586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5587 
 
5588 
  def __ne__(self, other):
5589 
    return not (self == other)
5590 
 
5326 rajveer 5591 
class getUserByCartId_result:
1491 vikas 5592 
  """
5593 
  Attributes:
5594 
   - success
5595 
   - ucex
5596 
  """
5597 
 
5598 
  thrift_spec = (
5599 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5600 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5601 
  )
5602 
 
5603 
  def __init__(self, success=None, ucex=None,):
5604 
    self.success = success
5605 
    self.ucex = ucex
5606 
 
5607 
  def read(self, iprot):
5608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5610 
      return
5611 
    iprot.readStructBegin()
5612 
    while True:
5613 
      (fname, ftype, fid) = iprot.readFieldBegin()
5614 
      if ftype == TType.STOP:
5615 
        break
5616 
      if fid == 0:
5617 
        if ftype == TType.STRUCT:
5618 
          self.success = User()
5619 
          self.success.read(iprot)
5620 
        else:
5621 
          iprot.skip(ftype)
5622 
      elif fid == 1:
5623 
        if ftype == TType.STRUCT:
5624 
          self.ucex = UserContextException()
5625 
          self.ucex.read(iprot)
5626 
        else:
5627 
          iprot.skip(ftype)
5628 
      else:
5629 
        iprot.skip(ftype)
5630 
      iprot.readFieldEnd()
5631 
    iprot.readStructEnd()
5632 
 
5633 
  def write(self, oprot):
5634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5636 
      return
5326 rajveer 5637 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5638 
    if self.success is not None:
1491 vikas 5639 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5640 
      self.success.write(oprot)
5641 
      oprot.writeFieldEnd()
3431 rajveer 5642 
    if self.ucex is not None:
1491 vikas 5643 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5644 
      self.ucex.write(oprot)
5645 
      oprot.writeFieldEnd()
5646 
    oprot.writeFieldStop()
5647 
    oprot.writeStructEnd()
5648 
 
3431 rajveer 5649 
  def validate(self):
5650 
    return
5651 
 
5652 
 
1491 vikas 5653 
  def __repr__(self):
5654 
    L = ['%s=%r' % (key, value)
5655 
      for key, value in self.__dict__.iteritems()]
5656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5657 
 
5658 
  def __eq__(self, other):
5659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5660 
 
5661 
  def __ne__(self, other):
5662 
    return not (self == other)
5663 
 
5326 rajveer 5664 
class getUserByEmail_args:
3032 mandeep.dh 5665 
  """
5666 
  Attributes:
5326 rajveer 5667 
   - email
3032 mandeep.dh 5668 
  """
5669 
 
5670 
  thrift_spec = (
5671 
    None, # 0
5326 rajveer 5672 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5673 
  )
5674 
 
5326 rajveer 5675 
  def __init__(self, email=None,):
5676 
    self.email = email
3032 mandeep.dh 5677 
 
5678 
  def read(self, iprot):
5679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5681 
      return
5682 
    iprot.readStructBegin()
5683 
    while True:
5684 
      (fname, ftype, fid) = iprot.readFieldBegin()
5685 
      if ftype == TType.STOP:
5686 
        break
5687 
      if fid == 1:
5326 rajveer 5688 
        if ftype == TType.STRING:
5689 
          self.email = iprot.readString();
3032 mandeep.dh 5690 
        else:
5691 
          iprot.skip(ftype)
5692 
      else:
5693 
        iprot.skip(ftype)
5694 
      iprot.readFieldEnd()
5695 
    iprot.readStructEnd()
5696 
 
5697 
  def write(self, oprot):
5698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5700 
      return
5326 rajveer 5701 
    oprot.writeStructBegin('getUserByEmail_args')
5702 
    if self.email is not None:
5703 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5704 
      oprot.writeString(self.email)
3032 mandeep.dh 5705 
      oprot.writeFieldEnd()
5706 
    oprot.writeFieldStop()
5707 
    oprot.writeStructEnd()
5708 
 
3431 rajveer 5709 
  def validate(self):
5710 
    return
5711 
 
5712 
 
3032 mandeep.dh 5713 
  def __repr__(self):
5714 
    L = ['%s=%r' % (key, value)
5715 
      for key, value in self.__dict__.iteritems()]
5716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5717 
 
5718 
  def __eq__(self, other):
5719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5720 
 
5721 
  def __ne__(self, other):
5722 
    return not (self == other)
5723 
 
5326 rajveer 5724 
class getUserByEmail_result:
3032 mandeep.dh 5725 
  """
5726 
  Attributes:
5727 
   - success
5728 
   - ucex
5729 
  """
5730 
 
5731 
  thrift_spec = (
5732 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5733 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5734 
  )
5735 
 
5736 
  def __init__(self, success=None, ucex=None,):
5737 
    self.success = success
5738 
    self.ucex = ucex
5739 
 
5740 
  def read(self, iprot):
5741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5743 
      return
5744 
    iprot.readStructBegin()
5745 
    while True:
5746 
      (fname, ftype, fid) = iprot.readFieldBegin()
5747 
      if ftype == TType.STOP:
5748 
        break
5749 
      if fid == 0:
5750 
        if ftype == TType.STRUCT:
5751 
          self.success = User()
5752 
          self.success.read(iprot)
5753 
        else:
5754 
          iprot.skip(ftype)
5755 
      elif fid == 1:
5756 
        if ftype == TType.STRUCT:
5757 
          self.ucex = UserContextException()
5758 
          self.ucex.read(iprot)
5759 
        else:
5760 
          iprot.skip(ftype)
5761 
      else:
5762 
        iprot.skip(ftype)
5763 
      iprot.readFieldEnd()
5764 
    iprot.readStructEnd()
5765 
 
5766 
  def write(self, oprot):
5767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5769 
      return
5326 rajveer 5770 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5771 
    if self.success is not None:
3032 mandeep.dh 5772 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5773 
      self.success.write(oprot)
5774 
      oprot.writeFieldEnd()
3431 rajveer 5775 
    if self.ucex is not None:
3032 mandeep.dh 5776 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5777 
      self.ucex.write(oprot)
5778 
      oprot.writeFieldEnd()
5779 
    oprot.writeFieldStop()
5780 
    oprot.writeStructEnd()
5781 
 
3431 rajveer 5782 
  def validate(self):
5783 
    return
5784 
 
5785 
 
3032 mandeep.dh 5786 
  def __repr__(self):
5787 
    L = ['%s=%r' % (key, value)
5788 
      for key, value in self.__dict__.iteritems()]
5789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5790 
 
5791 
  def __eq__(self, other):
5792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5793 
 
5794 
  def __ne__(self, other):
5795 
    return not (self == other)
5796 
 
5326 rajveer 5797 
class getUserByMobileNumber_args:
94 ashish 5798 
  """
5799 
  Attributes:
5326 rajveer 5800 
   - mobileNumber
94 ashish 5801 
  """
5802 
 
5803 
  thrift_spec = (
5804 
    None, # 0
5326 rajveer 5805 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5806 
  )
5807 
 
5326 rajveer 5808 
  def __init__(self, mobileNumber=None,):
5809 
    self.mobileNumber = mobileNumber
94 ashish 5810 
 
5811 
  def read(self, iprot):
5812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5814 
      return
5815 
    iprot.readStructBegin()
5816 
    while True:
5817 
      (fname, ftype, fid) = iprot.readFieldBegin()
5818 
      if ftype == TType.STOP:
5819 
        break
5820 
      if fid == 1:
5326 rajveer 5821 
        if ftype == TType.I64:
5822 
          self.mobileNumber = iprot.readI64();
94 ashish 5823 
        else:
5824 
          iprot.skip(ftype)
5825 
      else:
5826 
        iprot.skip(ftype)
5827 
      iprot.readFieldEnd()
5828 
    iprot.readStructEnd()
5829 
 
5830 
  def write(self, oprot):
5831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5833 
      return
5326 rajveer 5834 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5835 
    if self.mobileNumber is not None:
5836 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5837 
      oprot.writeI64(self.mobileNumber)
94 ashish 5838 
      oprot.writeFieldEnd()
5839 
    oprot.writeFieldStop()
5840 
    oprot.writeStructEnd()
5841 
 
3431 rajveer 5842 
  def validate(self):
5843 
    return
5844 
 
5845 
 
94 ashish 5846 
  def __repr__(self):
5847 
    L = ['%s=%r' % (key, value)
5848 
      for key, value in self.__dict__.iteritems()]
5849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5850 
 
5851 
  def __eq__(self, other):
5852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5853 
 
5854 
  def __ne__(self, other):
5855 
    return not (self == other)
5856 
 
5326 rajveer 5857 
class getUserByMobileNumber_result:
94 ashish 5858 
  """
5859 
  Attributes:
5860 
   - success
559 chandransh 5861 
   - ucex
94 ashish 5862 
  """
5863 
 
5864 
  thrift_spec = (
559 chandransh 5865 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5866 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5867 
  )
5868 
 
559 chandransh 5869 
  def __init__(self, success=None, ucex=None,):
94 ashish 5870 
    self.success = success
559 chandransh 5871 
    self.ucex = ucex
94 ashish 5872 
 
5873 
  def read(self, iprot):
5874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5876 
      return
5877 
    iprot.readStructBegin()
5878 
    while True:
5879 
      (fname, ftype, fid) = iprot.readFieldBegin()
5880 
      if ftype == TType.STOP:
5881 
        break
5882 
      if fid == 0:
5883 
        if ftype == TType.STRUCT:
559 chandransh 5884 
          self.success = User()
94 ashish 5885 
          self.success.read(iprot)
5886 
        else:
5887 
          iprot.skip(ftype)
5888 
      elif fid == 1:
5889 
        if ftype == TType.STRUCT:
559 chandransh 5890 
          self.ucex = UserContextException()
5891 
          self.ucex.read(iprot)
94 ashish 5892 
        else:
5893 
          iprot.skip(ftype)
5894 
      else:
5895 
        iprot.skip(ftype)
5896 
      iprot.readFieldEnd()
5897 
    iprot.readStructEnd()
5898 
 
5899 
  def write(self, oprot):
5900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5902 
      return
5326 rajveer 5903 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5904 
    if self.success is not None:
94 ashish 5905 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5906 
      self.success.write(oprot)
5907 
      oprot.writeFieldEnd()
3431 rajveer 5908 
    if self.ucex is not None:
559 chandransh 5909 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5910 
      self.ucex.write(oprot)
94 ashish 5911 
      oprot.writeFieldEnd()
5912 
    oprot.writeFieldStop()
5913 
    oprot.writeStructEnd()
5914 
 
3431 rajveer 5915 
  def validate(self):
5916 
    return
5917 
 
5918 
 
94 ashish 5919 
  def __repr__(self):
5920 
    L = ['%s=%r' % (key, value)
5921 
      for key, value in self.__dict__.iteritems()]
5922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5923 
 
5924 
  def __eq__(self, other):
5925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5926 
 
5927 
  def __ne__(self, other):
5928 
    return not (self == other)
5929 
 
5326 rajveer 5930 
class createUser_args:
94 ashish 5931 
  """
5932 
  Attributes:
559 chandransh 5933 
   - user
94 ashish 5934 
  """
5935 
 
5936 
  thrift_spec = (
5937 
    None, # 0
559 chandransh 5938 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5939 
  )
5940 
 
559 chandransh 5941 
  def __init__(self, user=None,):
5942 
    self.user = user
94 ashish 5943 
 
5944 
  def read(self, iprot):
5945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5947 
      return
5948 
    iprot.readStructBegin()
5949 
    while True:
5950 
      (fname, ftype, fid) = iprot.readFieldBegin()
5951 
      if ftype == TType.STOP:
5952 
        break
5953 
      if fid == 1:
559 chandransh 5954 
        if ftype == TType.STRUCT:
5955 
          self.user = User()
5956 
          self.user.read(iprot)
94 ashish 5957 
        else:
5958 
          iprot.skip(ftype)
5959 
      else:
5960 
        iprot.skip(ftype)
5961 
      iprot.readFieldEnd()
5962 
    iprot.readStructEnd()
5963 
 
5964 
  def write(self, oprot):
5965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5967 
      return
5326 rajveer 5968 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5969 
    if self.user is not None:
559 chandransh 5970 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5971 
      self.user.write(oprot)
94 ashish 5972 
      oprot.writeFieldEnd()
5973 
    oprot.writeFieldStop()
5974 
    oprot.writeStructEnd()
5975 
 
3431 rajveer 5976 
  def validate(self):
5977 
    return
5978 
 
5979 
 
94 ashish 5980 
  def __repr__(self):
5981 
    L = ['%s=%r' % (key, value)
5982 
      for key, value in self.__dict__.iteritems()]
5983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5984 
 
5985 
  def __eq__(self, other):
5986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5987 
 
5988 
  def __ne__(self, other):
5989 
    return not (self == other)
5990 
 
5326 rajveer 5991 
class createUser_result:
94 ashish 5992 
  """
5993 
  Attributes:
5994 
   - success
559 chandransh 5995 
   - ucex
94 ashish 5996 
  """
5997 
 
5998 
  thrift_spec = (
559 chandransh 5999 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6000 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6001 
  )
6002 
 
559 chandransh 6003 
  def __init__(self, success=None, ucex=None,):
94 ashish 6004 
    self.success = success
559 chandransh 6005 
    self.ucex = ucex
94 ashish 6006 
 
6007 
  def read(self, iprot):
6008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6010 
      return
6011 
    iprot.readStructBegin()
6012 
    while True:
6013 
      (fname, ftype, fid) = iprot.readFieldBegin()
6014 
      if ftype == TType.STOP:
6015 
        break
6016 
      if fid == 0:
6017 
        if ftype == TType.STRUCT:
559 chandransh 6018 
          self.success = User()
94 ashish 6019 
          self.success.read(iprot)
6020 
        else:
6021 
          iprot.skip(ftype)
6022 
      elif fid == 1:
6023 
        if ftype == TType.STRUCT:
559 chandransh 6024 
          self.ucex = UserContextException()
6025 
          self.ucex.read(iprot)
94 ashish 6026 
        else:
6027 
          iprot.skip(ftype)
6028 
      else:
6029 
        iprot.skip(ftype)
6030 
      iprot.readFieldEnd()
6031 
    iprot.readStructEnd()
6032 
 
6033 
  def write(self, oprot):
6034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6036 
      return
5326 rajveer 6037 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 6038 
    if self.success is not None:
94 ashish 6039 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6040 
      self.success.write(oprot)
6041 
      oprot.writeFieldEnd()
3431 rajveer 6042 
    if self.ucex is not None:
559 chandransh 6043 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6044 
      self.ucex.write(oprot)
94 ashish 6045 
      oprot.writeFieldEnd()
6046 
    oprot.writeFieldStop()
6047 
    oprot.writeStructEnd()
6048 
 
3431 rajveer 6049 
  def validate(self):
6050 
    return
6051 
 
6052 
 
94 ashish 6053 
  def __repr__(self):
6054 
    L = ['%s=%r' % (key, value)
6055 
      for key, value in self.__dict__.iteritems()]
6056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6057 
 
6058 
  def __eq__(self, other):
6059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6060 
 
6061 
  def __ne__(self, other):
6062 
    return not (self == other)
6063 
 
5326 rajveer 6064 
class updateUser_args:
94 ashish 6065 
  """
6066 
  Attributes:
5326 rajveer 6067 
   - user
94 ashish 6068 
  """
6069 
 
6070 
  thrift_spec = (
6071 
    None, # 0
5326 rajveer 6072 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 6073 
  )
6074 
 
5326 rajveer 6075 
  def __init__(self, user=None,):
6076 
    self.user = user
94 ashish 6077 
 
6078 
  def read(self, iprot):
6079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6081 
      return
6082 
    iprot.readStructBegin()
6083 
    while True:
6084 
      (fname, ftype, fid) = iprot.readFieldBegin()
6085 
      if ftype == TType.STOP:
6086 
        break
6087 
      if fid == 1:
5326 rajveer 6088 
        if ftype == TType.STRUCT:
6089 
          self.user = User()
6090 
          self.user.read(iprot)
94 ashish 6091 
        else:
6092 
          iprot.skip(ftype)
6093 
      else:
6094 
        iprot.skip(ftype)
6095 
      iprot.readFieldEnd()
6096 
    iprot.readStructEnd()
6097 
 
6098 
  def write(self, oprot):
6099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6101 
      return
5326 rajveer 6102 
    oprot.writeStructBegin('updateUser_args')
6103 
    if self.user is not None:
6104 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6105 
      self.user.write(oprot)
94 ashish 6106 
      oprot.writeFieldEnd()
6107 
    oprot.writeFieldStop()
6108 
    oprot.writeStructEnd()
6109 
 
3431 rajveer 6110 
  def validate(self):
6111 
    return
6112 
 
6113 
 
94 ashish 6114 
  def __repr__(self):
6115 
    L = ['%s=%r' % (key, value)
6116 
      for key, value in self.__dict__.iteritems()]
6117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6118 
 
6119 
  def __eq__(self, other):
6120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6121 
 
6122 
  def __ne__(self, other):
6123 
    return not (self == other)
6124 
 
5326 rajveer 6125 
class updateUser_result:
94 ashish 6126 
  """
6127 
  Attributes:
6128 
   - success
559 chandransh 6129 
   - ucex
94 ashish 6130 
  """
6131 
 
6132 
  thrift_spec = (
5326 rajveer 6133 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6134 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6135 
  )
6136 
 
559 chandransh 6137 
  def __init__(self, success=None, ucex=None,):
94 ashish 6138 
    self.success = success
559 chandransh 6139 
    self.ucex = ucex
94 ashish 6140 
 
6141 
  def read(self, iprot):
6142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6144 
      return
6145 
    iprot.readStructBegin()
6146 
    while True:
6147 
      (fname, ftype, fid) = iprot.readFieldBegin()
6148 
      if ftype == TType.STOP:
6149 
        break
6150 
      if fid == 0:
5326 rajveer 6151 
        if ftype == TType.STRUCT:
6152 
          self.success = User()
6153 
          self.success.read(iprot)
94 ashish 6154 
        else:
6155 
          iprot.skip(ftype)
6156 
      elif fid == 1:
6157 
        if ftype == TType.STRUCT:
559 chandransh 6158 
          self.ucex = UserContextException()
6159 
          self.ucex.read(iprot)
94 ashish 6160 
        else:
6161 
          iprot.skip(ftype)
6162 
      else:
6163 
        iprot.skip(ftype)
6164 
      iprot.readFieldEnd()
6165 
    iprot.readStructEnd()
6166 
 
6167 
  def write(self, oprot):
6168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6170 
      return
5326 rajveer 6171 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6172 
    if self.success is not None:
5326 rajveer 6173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6174 
      self.success.write(oprot)
94 ashish 6175 
      oprot.writeFieldEnd()
3431 rajveer 6176 
    if self.ucex is not None:
559 chandransh 6177 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6178 
      self.ucex.write(oprot)
94 ashish 6179 
      oprot.writeFieldEnd()
6180 
    oprot.writeFieldStop()
6181 
    oprot.writeStructEnd()
6182 
 
3431 rajveer 6183 
  def validate(self):
6184 
    return
6185 
 
6186 
 
94 ashish 6187 
  def __repr__(self):
6188 
    L = ['%s=%r' % (key, value)
6189 
      for key, value in self.__dict__.iteritems()]
6190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6191 
 
6192 
  def __eq__(self, other):
6193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6194 
 
6195 
  def __ne__(self, other):
6196 
    return not (self == other)
6197 
 
559 chandransh 6198 
class authenticateUser_args:
94 ashish 6199 
  """
6200 
  Attributes:
6201 
   - email
6202 
   - password
6203 
  """
6204 
 
6205 
  thrift_spec = (
6206 
    None, # 0
6207 
    (1, TType.STRING, 'email', None, None, ), # 1
6208 
    (2, TType.STRING, 'password', None, None, ), # 2
6209 
  )
6210 
 
6211 
  def __init__(self, email=None, password=None,):
6212 
    self.email = email
6213 
    self.password = password
6214 
 
6215 
  def read(self, iprot):
6216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6218 
      return
6219 
    iprot.readStructBegin()
6220 
    while True:
6221 
      (fname, ftype, fid) = iprot.readFieldBegin()
6222 
      if ftype == TType.STOP:
6223 
        break
6224 
      if fid == 1:
6225 
        if ftype == TType.STRING:
6226 
          self.email = iprot.readString();
6227 
        else:
6228 
          iprot.skip(ftype)
6229 
      elif fid == 2:
6230 
        if ftype == TType.STRING:
6231 
          self.password = iprot.readString();
6232 
        else:
6233 
          iprot.skip(ftype)
6234 
      else:
6235 
        iprot.skip(ftype)
6236 
      iprot.readFieldEnd()
6237 
    iprot.readStructEnd()
6238 
 
6239 
  def write(self, oprot):
6240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6242 
      return
559 chandransh 6243 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6244 
    if self.email is not None:
94 ashish 6245 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6246 
      oprot.writeString(self.email)
6247 
      oprot.writeFieldEnd()
3431 rajveer 6248 
    if self.password is not None:
94 ashish 6249 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6250 
      oprot.writeString(self.password)
6251 
      oprot.writeFieldEnd()
6252 
    oprot.writeFieldStop()
6253 
    oprot.writeStructEnd()
6254 
 
3431 rajveer 6255 
  def validate(self):
6256 
    return
6257 
 
6258 
 
94 ashish 6259 
  def __repr__(self):
6260 
    L = ['%s=%r' % (key, value)
6261 
      for key, value in self.__dict__.iteritems()]
6262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6263 
 
6264 
  def __eq__(self, other):
6265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6266 
 
6267 
  def __ne__(self, other):
6268 
    return not (self == other)
6269 
 
559 chandransh 6270 
class authenticateUser_result:
94 ashish 6271 
  """
6272 
  Attributes:
6273 
   - success
559 chandransh 6274 
   - auex
94 ashish 6275 
  """
6276 
 
6277 
  thrift_spec = (
559 chandransh 6278 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6279 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6280 
  )
6281 
 
559 chandransh 6282 
  def __init__(self, success=None, auex=None,):
94 ashish 6283 
    self.success = success
559 chandransh 6284 
    self.auex = auex
94 ashish 6285 
 
6286 
  def read(self, iprot):
6287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6289 
      return
6290 
    iprot.readStructBegin()
6291 
    while True:
6292 
      (fname, ftype, fid) = iprot.readFieldBegin()
6293 
      if ftype == TType.STOP:
6294 
        break
6295 
      if fid == 0:
6296 
        if ftype == TType.STRUCT:
559 chandransh 6297 
          self.success = User()
94 ashish 6298 
          self.success.read(iprot)
6299 
        else:
6300 
          iprot.skip(ftype)
6301 
      elif fid == 1:
6302 
        if ftype == TType.STRUCT:
559 chandransh 6303 
          self.auex = AuthenticationException()
6304 
          self.auex.read(iprot)
94 ashish 6305 
        else:
6306 
          iprot.skip(ftype)
6307 
      else:
6308 
        iprot.skip(ftype)
6309 
      iprot.readFieldEnd()
6310 
    iprot.readStructEnd()
6311 
 
6312 
  def write(self, oprot):
6313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6315 
      return
559 chandransh 6316 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6317 
    if self.success is not None:
94 ashish 6318 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6319 
      self.success.write(oprot)
6320 
      oprot.writeFieldEnd()
3431 rajveer 6321 
    if self.auex is not None:
559 chandransh 6322 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6323 
      self.auex.write(oprot)
94 ashish 6324 
      oprot.writeFieldEnd()
6325 
    oprot.writeFieldStop()
6326 
    oprot.writeStructEnd()
6327 
 
3431 rajveer 6328 
  def validate(self):
6329 
    return
6330 
 
6331 
 
94 ashish 6332 
  def __repr__(self):
6333 
    L = ['%s=%r' % (key, value)
6334 
      for key, value in self.__dict__.iteritems()]
6335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6336 
 
6337 
  def __eq__(self, other):
6338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6339 
 
6340 
  def __ne__(self, other):
6341 
    return not (self == other)
6342 
 
559 chandransh 6343 
class userExists_args:
122 ashish 6344 
  """
6345 
  Attributes:
559 chandransh 6346 
   - email
122 ashish 6347 
  """
6348 
 
6349 
  thrift_spec = (
6350 
    None, # 0
559 chandransh 6351 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6352 
  )
6353 
 
559 chandransh 6354 
  def __init__(self, email=None,):
6355 
    self.email = email
122 ashish 6356 
 
6357 
  def read(self, iprot):
6358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6360 
      return
6361 
    iprot.readStructBegin()
6362 
    while True:
6363 
      (fname, ftype, fid) = iprot.readFieldBegin()
6364 
      if ftype == TType.STOP:
6365 
        break
6366 
      if fid == 1:
6367 
        if ftype == TType.STRING:
559 chandransh 6368 
          self.email = iprot.readString();
122 ashish 6369 
        else:
6370 
          iprot.skip(ftype)
559 chandransh 6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
6380 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6381 
    if self.email is not None:
559 chandransh 6382 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6383 
      oprot.writeString(self.email)
6384 
      oprot.writeFieldEnd()
6385 
    oprot.writeFieldStop()
6386 
    oprot.writeStructEnd()
6387 
 
3431 rajveer 6388 
  def validate(self):
6389 
    return
6390 
 
6391 
 
559 chandransh 6392 
  def __repr__(self):
6393 
    L = ['%s=%r' % (key, value)
6394 
      for key, value in self.__dict__.iteritems()]
6395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6396 
 
6397 
  def __eq__(self, other):
6398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6399 
 
6400 
  def __ne__(self, other):
6401 
    return not (self == other)
6402 
 
6403 
class userExists_result:
6404 
  """
6405 
  Attributes:
6406 
   - success
6407 
   - ucx
6408 
  """
6409 
 
6410 
  thrift_spec = (
6411 
    (0, TType.BOOL, 'success', None, None, ), # 0
6412 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6413 
  )
6414 
 
6415 
  def __init__(self, success=None, ucx=None,):
6416 
    self.success = success
6417 
    self.ucx = ucx
6418 
 
6419 
  def read(self, iprot):
6420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6422 
      return
6423 
    iprot.readStructBegin()
6424 
    while True:
6425 
      (fname, ftype, fid) = iprot.readFieldBegin()
6426 
      if ftype == TType.STOP:
6427 
        break
6428 
      if fid == 0:
6429 
        if ftype == TType.BOOL:
6430 
          self.success = iprot.readBool();
6431 
        else:
6432 
          iprot.skip(ftype)
6433 
      elif fid == 1:
6434 
        if ftype == TType.STRUCT:
6435 
          self.ucx = UserContextException()
6436 
          self.ucx.read(iprot)
6437 
        else:
6438 
          iprot.skip(ftype)
6439 
      else:
6440 
        iprot.skip(ftype)
6441 
      iprot.readFieldEnd()
6442 
    iprot.readStructEnd()
6443 
 
6444 
  def write(self, oprot):
6445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6447 
      return
6448 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6449 
    if self.success is not None:
559 chandransh 6450 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6451 
      oprot.writeBool(self.success)
6452 
      oprot.writeFieldEnd()
3431 rajveer 6453 
    if self.ucx is not None:
559 chandransh 6454 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6455 
      self.ucx.write(oprot)
6456 
      oprot.writeFieldEnd()
6457 
    oprot.writeFieldStop()
6458 
    oprot.writeStructEnd()
6459 
 
3431 rajveer 6460 
  def validate(self):
6461 
    return
6462 
 
6463 
 
559 chandransh 6464 
  def __repr__(self):
6465 
    L = ['%s=%r' % (key, value)
6466 
      for key, value in self.__dict__.iteritems()]
6467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6468 
 
6469 
  def __eq__(self, other):
6470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6471 
 
6472 
  def __ne__(self, other):
6473 
    return not (self == other)
6474 
 
6475 
class addAddressForUser_args:
6476 
  """
6477 
  Attributes:
6478 
   - userId
6479 
   - address
6480 
   - setDefault
6481 
  """
6482 
 
6483 
  thrift_spec = (
6484 
    None, # 0
6485 
    (1, TType.I64, 'userId', None, None, ), # 1
6486 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6487 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6488 
  )
6489 
 
567 rajveer 6490 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6491 
    self.userId = userId
6492 
    self.address = address
6493 
    self.setDefault = setDefault
6494 
 
6495 
  def read(self, iprot):
6496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6498 
      return
6499 
    iprot.readStructBegin()
6500 
    while True:
6501 
      (fname, ftype, fid) = iprot.readFieldBegin()
6502 
      if ftype == TType.STOP:
6503 
        break
6504 
      if fid == 1:
6505 
        if ftype == TType.I64:
6506 
          self.userId = iprot.readI64();
6507 
        else:
6508 
          iprot.skip(ftype)
122 ashish 6509 
      elif fid == 2:
559 chandransh 6510 
        if ftype == TType.STRUCT:
6511 
          self.address = Address()
6512 
          self.address.read(iprot)
122 ashish 6513 
        else:
6514 
          iprot.skip(ftype)
6515 
      elif fid == 3:
6516 
        if ftype == TType.BOOL:
559 chandransh 6517 
          self.setDefault = iprot.readBool();
122 ashish 6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      else:
6521 
        iprot.skip(ftype)
6522 
      iprot.readFieldEnd()
6523 
    iprot.readStructEnd()
6524 
 
6525 
  def write(self, oprot):
6526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6528 
      return
559 chandransh 6529 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6530 
    if self.userId is not None:
559 chandransh 6531 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6532 
      oprot.writeI64(self.userId)
122 ashish 6533 
      oprot.writeFieldEnd()
3431 rajveer 6534 
    if self.address is not None:
559 chandransh 6535 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6536 
      self.address.write(oprot)
122 ashish 6537 
      oprot.writeFieldEnd()
3431 rajveer 6538 
    if self.setDefault is not None:
567 rajveer 6539 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6540 
      oprot.writeBool(self.setDefault)
6541 
      oprot.writeFieldEnd()
122 ashish 6542 
    oprot.writeFieldStop()
6543 
    oprot.writeStructEnd()
6544 
 
3431 rajveer 6545 
  def validate(self):
6546 
    return
6547 
 
6548 
 
122 ashish 6549 
  def __repr__(self):
6550 
    L = ['%s=%r' % (key, value)
6551 
      for key, value in self.__dict__.iteritems()]
6552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6553 
 
6554 
  def __eq__(self, other):
6555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6556 
 
6557 
  def __ne__(self, other):
6558 
    return not (self == other)
6559 
 
559 chandransh 6560 
class addAddressForUser_result:
122 ashish 6561 
  """
6562 
  Attributes:
6563 
   - success
559 chandransh 6564 
   - ucx
122 ashish 6565 
  """
6566 
 
6567 
  thrift_spec = (
567 rajveer 6568 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6569 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6570 
  )
6571 
 
559 chandransh 6572 
  def __init__(self, success=None, ucx=None,):
122 ashish 6573 
    self.success = success
559 chandransh 6574 
    self.ucx = ucx
122 ashish 6575 
 
6576 
  def read(self, iprot):
6577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6579 
      return
6580 
    iprot.readStructBegin()
6581 
    while True:
6582 
      (fname, ftype, fid) = iprot.readFieldBegin()
6583 
      if ftype == TType.STOP:
6584 
        break
6585 
      if fid == 0:
567 rajveer 6586 
        if ftype == TType.I64:
6587 
          self.success = iprot.readI64();
122 ashish 6588 
        else:
6589 
          iprot.skip(ftype)
6590 
      elif fid == 1:
6591 
        if ftype == TType.STRUCT:
559 chandransh 6592 
          self.ucx = UserContextException()
6593 
          self.ucx.read(iprot)
122 ashish 6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      else:
6597 
        iprot.skip(ftype)
6598 
      iprot.readFieldEnd()
6599 
    iprot.readStructEnd()
6600 
 
6601 
  def write(self, oprot):
6602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6604 
      return
559 chandransh 6605 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6606 
    if self.success is not None:
567 rajveer 6607 
      oprot.writeFieldBegin('success', TType.I64, 0)
6608 
      oprot.writeI64(self.success)
122 ashish 6609 
      oprot.writeFieldEnd()
3431 rajveer 6610 
    if self.ucx is not None:
559 chandransh 6611 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6612 
      self.ucx.write(oprot)
122 ashish 6613 
      oprot.writeFieldEnd()
6614 
    oprot.writeFieldStop()
6615 
    oprot.writeStructEnd()
6616 
 
3431 rajveer 6617 
  def validate(self):
6618 
    return
6619 
 
6620 
 
122 ashish 6621 
  def __repr__(self):
6622 
    L = ['%s=%r' % (key, value)
6623 
      for key, value in self.__dict__.iteritems()]
6624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6625 
 
6626 
  def __eq__(self, other):
6627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6628 
 
6629 
  def __ne__(self, other):
6630 
    return not (self == other)
6631 
 
559 chandransh 6632 
class removeAddressForUser_args:
94 ashish 6633 
  """
6634 
  Attributes:
559 chandransh 6635 
   - userid
6636 
   - addressId
94 ashish 6637 
  """
6638 
 
6639 
  thrift_spec = (
6640 
    None, # 0
559 chandransh 6641 
    (1, TType.I64, 'userid', None, None, ), # 1
6642 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6643 
  )
6644 
 
559 chandransh 6645 
  def __init__(self, userid=None, addressId=None,):
6646 
    self.userid = userid
6647 
    self.addressId = addressId
94 ashish 6648 
 
6649 
  def read(self, iprot):
6650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6652 
      return
6653 
    iprot.readStructBegin()
6654 
    while True:
6655 
      (fname, ftype, fid) = iprot.readFieldBegin()
6656 
      if ftype == TType.STOP:
6657 
        break
6658 
      if fid == 1:
559 chandransh 6659 
        if ftype == TType.I64:
6660 
          self.userid = iprot.readI64();
94 ashish 6661 
        else:
6662 
          iprot.skip(ftype)
559 chandransh 6663 
      elif fid == 2:
6664 
        if ftype == TType.I64:
6665 
          self.addressId = iprot.readI64();
6666 
        else:
6667 
          iprot.skip(ftype)
94 ashish 6668 
      else:
6669 
        iprot.skip(ftype)
6670 
      iprot.readFieldEnd()
6671 
    iprot.readStructEnd()
6672 
 
6673 
  def write(self, oprot):
6674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6676 
      return
559 chandransh 6677 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6678 
    if self.userid is not None:
559 chandransh 6679 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6680 
      oprot.writeI64(self.userid)
94 ashish 6681 
      oprot.writeFieldEnd()
3431 rajveer 6682 
    if self.addressId is not None:
559 chandransh 6683 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6684 
      oprot.writeI64(self.addressId)
6685 
      oprot.writeFieldEnd()
94 ashish 6686 
    oprot.writeFieldStop()
6687 
    oprot.writeStructEnd()
6688 
 
3431 rajveer 6689 
  def validate(self):
6690 
    return
6691 
 
6692 
 
94 ashish 6693 
  def __repr__(self):
6694 
    L = ['%s=%r' % (key, value)
6695 
      for key, value in self.__dict__.iteritems()]
6696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6697 
 
6698 
  def __eq__(self, other):
6699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6700 
 
6701 
  def __ne__(self, other):
6702 
    return not (self == other)
6703 
 
559 chandransh 6704 
class removeAddressForUser_result:
94 ashish 6705 
  """
6706 
  Attributes:
6707 
   - success
6708 
   - ucx
6709 
  """
6710 
 
6711 
  thrift_spec = (
6712 
    (0, TType.BOOL, 'success', None, None, ), # 0
6713 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6714 
  )
6715 
 
6716 
  def __init__(self, success=None, ucx=None,):
6717 
    self.success = success
6718 
    self.ucx = ucx
6719 
 
6720 
  def read(self, iprot):
6721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6723 
      return
6724 
    iprot.readStructBegin()
6725 
    while True:
6726 
      (fname, ftype, fid) = iprot.readFieldBegin()
6727 
      if ftype == TType.STOP:
6728 
        break
6729 
      if fid == 0:
6730 
        if ftype == TType.BOOL:
6731 
          self.success = iprot.readBool();
6732 
        else:
6733 
          iprot.skip(ftype)
6734 
      elif fid == 1:
6735 
        if ftype == TType.STRUCT:
6736 
          self.ucx = UserContextException()
6737 
          self.ucx.read(iprot)
6738 
        else:
6739 
          iprot.skip(ftype)
6740 
      else:
6741 
        iprot.skip(ftype)
6742 
      iprot.readFieldEnd()
6743 
    iprot.readStructEnd()
6744 
 
6745 
  def write(self, oprot):
6746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6748 
      return
559 chandransh 6749 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6750 
    if self.success is not None:
94 ashish 6751 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6752 
      oprot.writeBool(self.success)
6753 
      oprot.writeFieldEnd()
3431 rajveer 6754 
    if self.ucx is not None:
94 ashish 6755 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6756 
      self.ucx.write(oprot)
6757 
      oprot.writeFieldEnd()
6758 
    oprot.writeFieldStop()
6759 
    oprot.writeStructEnd()
6760 
 
3431 rajveer 6761 
  def validate(self):
6762 
    return
6763 
 
6764 
 
94 ashish 6765 
  def __repr__(self):
6766 
    L = ['%s=%r' % (key, value)
6767 
      for key, value in self.__dict__.iteritems()]
6768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6769 
 
6770 
  def __eq__(self, other):
6771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6772 
 
6773 
  def __ne__(self, other):
6774 
    return not (self == other)
6775 
 
559 chandransh 6776 
class setUserAsLoggedIn_args:
94 ashish 6777 
  """
6778 
  Attributes:
559 chandransh 6779 
   - userId
94 ashish 6780 
   - timestamp
6781 
  """
6782 
 
6783 
  thrift_spec = (
6784 
    None, # 0
559 chandransh 6785 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6786 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6787 
  )
6788 
 
559 chandransh 6789 
  def __init__(self, userId=None, timestamp=None,):
6790 
    self.userId = userId
94 ashish 6791 
    self.timestamp = timestamp
6792 
 
6793 
  def read(self, iprot):
6794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6796 
      return
6797 
    iprot.readStructBegin()
6798 
    while True:
6799 
      (fname, ftype, fid) = iprot.readFieldBegin()
6800 
      if ftype == TType.STOP:
6801 
        break
6802 
      if fid == 1:
559 chandransh 6803 
        if ftype == TType.I64:
6804 
          self.userId = iprot.readI64();
94 ashish 6805 
        else:
6806 
          iprot.skip(ftype)
6807 
      elif fid == 2:
6808 
        if ftype == TType.I64:
6809 
          self.timestamp = iprot.readI64();
6810 
        else:
6811 
          iprot.skip(ftype)
6812 
      else:
6813 
        iprot.skip(ftype)
6814 
      iprot.readFieldEnd()
6815 
    iprot.readStructEnd()
6816 
 
6817 
  def write(self, oprot):
6818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6820 
      return
559 chandransh 6821 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6822 
    if self.userId is not None:
559 chandransh 6823 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6824 
      oprot.writeI64(self.userId)
94 ashish 6825 
      oprot.writeFieldEnd()
3431 rajveer 6826 
    if self.timestamp is not None:
94 ashish 6827 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6828 
      oprot.writeI64(self.timestamp)
6829 
      oprot.writeFieldEnd()
6830 
    oprot.writeFieldStop()
6831 
    oprot.writeStructEnd()
6832 
 
3431 rajveer 6833 
  def validate(self):
6834 
    return
6835 
 
6836 
 
94 ashish 6837 
  def __repr__(self):
6838 
    L = ['%s=%r' % (key, value)
6839 
      for key, value in self.__dict__.iteritems()]
6840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6841 
 
6842 
  def __eq__(self, other):
6843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6844 
 
6845 
  def __ne__(self, other):
6846 
    return not (self == other)
6847 
 
559 chandransh 6848 
class setUserAsLoggedIn_result:
94 ashish 6849 
  """
6850 
  Attributes:
6851 
   - success
6852 
   - ucx
6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    (0, TType.BOOL, 'success', None, None, ), # 0
6857 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6858 
  )
6859 
 
6860 
  def __init__(self, success=None, ucx=None,):
6861 
    self.success = success
6862 
    self.ucx = ucx
6863 
 
6864 
  def read(self, iprot):
6865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6867 
      return
6868 
    iprot.readStructBegin()
6869 
    while True:
6870 
      (fname, ftype, fid) = iprot.readFieldBegin()
6871 
      if ftype == TType.STOP:
6872 
        break
6873 
      if fid == 0:
6874 
        if ftype == TType.BOOL:
6875 
          self.success = iprot.readBool();
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      elif fid == 1:
6879 
        if ftype == TType.STRUCT:
6880 
          self.ucx = UserContextException()
6881 
          self.ucx.read(iprot)
6882 
        else:
6883 
          iprot.skip(ftype)
6884 
      else:
6885 
        iprot.skip(ftype)
6886 
      iprot.readFieldEnd()
6887 
    iprot.readStructEnd()
6888 
 
6889 
  def write(self, oprot):
6890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6892 
      return
559 chandransh 6893 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6894 
    if self.success is not None:
94 ashish 6895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6896 
      oprot.writeBool(self.success)
6897 
      oprot.writeFieldEnd()
3431 rajveer 6898 
    if self.ucx is not None:
94 ashish 6899 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6900 
      self.ucx.write(oprot)
6901 
      oprot.writeFieldEnd()
6902 
    oprot.writeFieldStop()
6903 
    oprot.writeStructEnd()
6904 
 
3431 rajveer 6905 
  def validate(self):
6906 
    return
6907 
 
6908 
 
94 ashish 6909 
  def __repr__(self):
6910 
    L = ['%s=%r' % (key, value)
6911 
      for key, value in self.__dict__.iteritems()]
6912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6913 
 
6914 
  def __eq__(self, other):
6915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6916 
 
6917 
  def __ne__(self, other):
6918 
    return not (self == other)
6919 
 
559 chandransh 6920 
class setUserAsLoggedOut_args:
94 ashish 6921 
  """
6922 
  Attributes:
6923 
   - userid
6924 
   - timestamp
6925 
  """
6926 
 
6927 
  thrift_spec = (
6928 
    None, # 0
559 chandransh 6929 
    (1, TType.I64, 'userid', None, None, ), # 1
6930 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6931 
  )
6932 
 
559 chandransh 6933 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6934 
    self.userid = userid
6935 
    self.timestamp = timestamp
6936 
 
6937 
  def read(self, iprot):
6938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6940 
      return
6941 
    iprot.readStructBegin()
6942 
    while True:
6943 
      (fname, ftype, fid) = iprot.readFieldBegin()
6944 
      if ftype == TType.STOP:
6945 
        break
6946 
      if fid == 1:
6947 
        if ftype == TType.I64:
6948 
          self.userid = iprot.readI64();
6949 
        else:
6950 
          iprot.skip(ftype)
559 chandransh 6951 
      elif fid == 2:
94 ashish 6952 
        if ftype == TType.I64:
6953 
          self.timestamp = iprot.readI64();
6954 
        else:
6955 
          iprot.skip(ftype)
6956 
      else:
6957 
        iprot.skip(ftype)
6958 
      iprot.readFieldEnd()
6959 
    iprot.readStructEnd()
6960 
 
6961 
  def write(self, oprot):
6962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6964 
      return
559 chandransh 6965 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6966 
    if self.userid is not None:
559 chandransh 6967 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6968 
      oprot.writeI64(self.userid)
6969 
      oprot.writeFieldEnd()
3431 rajveer 6970 
    if self.timestamp is not None:
559 chandransh 6971 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6972 
      oprot.writeI64(self.timestamp)
6973 
      oprot.writeFieldEnd()
6974 
    oprot.writeFieldStop()
6975 
    oprot.writeStructEnd()
6976 
 
3431 rajveer 6977 
  def validate(self):
6978 
    return
6979 
 
6980 
 
94 ashish 6981 
  def __repr__(self):
6982 
    L = ['%s=%r' % (key, value)
6983 
      for key, value in self.__dict__.iteritems()]
6984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6985 
 
6986 
  def __eq__(self, other):
6987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6988 
 
6989 
  def __ne__(self, other):
6990 
    return not (self == other)
6991 
 
559 chandransh 6992 
class setUserAsLoggedOut_result:
94 ashish 6993 
  """
6994 
  Attributes:
6995 
   - success
6996 
   - ucx
6997 
  """
6998 
 
6999 
  thrift_spec = (
7000 
    (0, TType.BOOL, 'success', None, None, ), # 0
7001 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7002 
  )
7003 
 
7004 
  def __init__(self, success=None, ucx=None,):
7005 
    self.success = success
7006 
    self.ucx = ucx
7007 
 
7008 
  def read(self, iprot):
7009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7011 
      return
7012 
    iprot.readStructBegin()
7013 
    while True:
7014 
      (fname, ftype, fid) = iprot.readFieldBegin()
7015 
      if ftype == TType.STOP:
7016 
        break
7017 
      if fid == 0:
7018 
        if ftype == TType.BOOL:
7019 
          self.success = iprot.readBool();
7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      elif fid == 1:
7023 
        if ftype == TType.STRUCT:
7024 
          self.ucx = UserContextException()
7025 
          self.ucx.read(iprot)
7026 
        else:
7027 
          iprot.skip(ftype)
7028 
      else:
7029 
        iprot.skip(ftype)
7030 
      iprot.readFieldEnd()
7031 
    iprot.readStructEnd()
7032 
 
7033 
  def write(self, oprot):
7034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7036 
      return
559 chandransh 7037 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 7038 
    if self.success is not None:
94 ashish 7039 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7040 
      oprot.writeBool(self.success)
7041 
      oprot.writeFieldEnd()
3431 rajveer 7042 
    if self.ucx is not None:
94 ashish 7043 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7044 
      self.ucx.write(oprot)
7045 
      oprot.writeFieldEnd()
7046 
    oprot.writeFieldStop()
7047 
    oprot.writeStructEnd()
7048 
 
3431 rajveer 7049 
  def validate(self):
7050 
    return
7051 
 
7052 
 
94 ashish 7053 
  def __repr__(self):
7054 
    L = ['%s=%r' % (key, value)
7055 
      for key, value in self.__dict__.iteritems()]
7056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7057 
 
7058 
  def __eq__(self, other):
7059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7060 
 
7061 
  def __ne__(self, other):
7062 
    return not (self == other)
7063 
 
559 chandransh 7064 
class setDefaultAddress_args:
94 ashish 7065 
  """
7066 
  Attributes:
7067 
   - userid
7068 
   - addressId
7069 
  """
7070 
 
7071 
  thrift_spec = (
7072 
    None, # 0
7073 
    (1, TType.I64, 'userid', None, None, ), # 1
7074 
    (2, TType.I64, 'addressId', None, None, ), # 2
7075 
  )
7076 
 
7077 
  def __init__(self, userid=None, addressId=None,):
7078 
    self.userid = userid
7079 
    self.addressId = addressId
7080 
 
7081 
  def read(self, iprot):
7082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7084 
      return
7085 
    iprot.readStructBegin()
7086 
    while True:
7087 
      (fname, ftype, fid) = iprot.readFieldBegin()
7088 
      if ftype == TType.STOP:
7089 
        break
7090 
      if fid == 1:
7091 
        if ftype == TType.I64:
7092 
          self.userid = iprot.readI64();
7093 
        else:
7094 
          iprot.skip(ftype)
7095 
      elif fid == 2:
7096 
        if ftype == TType.I64:
7097 
          self.addressId = iprot.readI64();
7098 
        else:
7099 
          iprot.skip(ftype)
7100 
      else:
7101 
        iprot.skip(ftype)
7102 
      iprot.readFieldEnd()
7103 
    iprot.readStructEnd()
7104 
 
7105 
  def write(self, oprot):
7106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7108 
      return
559 chandransh 7109 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7110 
    if self.userid is not None:
94 ashish 7111 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7112 
      oprot.writeI64(self.userid)
7113 
      oprot.writeFieldEnd()
3431 rajveer 7114 
    if self.addressId is not None:
94 ashish 7115 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7116 
      oprot.writeI64(self.addressId)
7117 
      oprot.writeFieldEnd()
7118 
    oprot.writeFieldStop()
7119 
    oprot.writeStructEnd()
7120 
 
3431 rajveer 7121 
  def validate(self):
7122 
    return
7123 
 
7124 
 
94 ashish 7125 
  def __repr__(self):
7126 
    L = ['%s=%r' % (key, value)
7127 
      for key, value in self.__dict__.iteritems()]
7128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7129 
 
7130 
  def __eq__(self, other):
7131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7132 
 
7133 
  def __ne__(self, other):
7134 
    return not (self == other)
7135 
 
559 chandransh 7136 
class setDefaultAddress_result:
94 ashish 7137 
  """
7138 
  Attributes:
7139 
   - success
7140 
   - ucx
7141 
  """
7142 
 
7143 
  thrift_spec = (
7144 
    (0, TType.BOOL, 'success', None, None, ), # 0
7145 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7146 
  )
7147 
 
7148 
  def __init__(self, success=None, ucx=None,):
7149 
    self.success = success
7150 
    self.ucx = ucx
7151 
 
7152 
  def read(self, iprot):
7153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7155 
      return
7156 
    iprot.readStructBegin()
7157 
    while True:
7158 
      (fname, ftype, fid) = iprot.readFieldBegin()
7159 
      if ftype == TType.STOP:
7160 
        break
7161 
      if fid == 0:
7162 
        if ftype == TType.BOOL:
7163 
          self.success = iprot.readBool();
7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      elif fid == 1:
7167 
        if ftype == TType.STRUCT:
7168 
          self.ucx = UserContextException()
7169 
          self.ucx.read(iprot)
7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      else:
7173 
        iprot.skip(ftype)
7174 
      iprot.readFieldEnd()
7175 
    iprot.readStructEnd()
7176 
 
7177 
  def write(self, oprot):
7178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7180 
      return
559 chandransh 7181 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7182 
    if self.success is not None:
94 ashish 7183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7184 
      oprot.writeBool(self.success)
7185 
      oprot.writeFieldEnd()
3431 rajveer 7186 
    if self.ucx is not None:
94 ashish 7187 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7188 
      self.ucx.write(oprot)
7189 
      oprot.writeFieldEnd()
7190 
    oprot.writeFieldStop()
7191 
    oprot.writeStructEnd()
7192 
 
3431 rajveer 7193 
  def validate(self):
7194 
    return
7195 
 
7196 
 
94 ashish 7197 
  def __repr__(self):
7198 
    L = ['%s=%r' % (key, value)
7199 
      for key, value in self.__dict__.iteritems()]
7200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7201 
 
7202 
  def __eq__(self, other):
7203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7204 
 
7205 
  def __ne__(self, other):
7206 
    return not (self == other)
7207 
 
559 chandransh 7208 
class updatePassword_args:
94 ashish 7209 
  """
7210 
  Attributes:
559 chandransh 7211 
   - userid
594 rajveer 7212 
   - oldPassword
7213 
   - newPassword
94 ashish 7214 
  """
7215 
 
7216 
  thrift_spec = (
7217 
    None, # 0
559 chandransh 7218 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7219 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7220 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7221 
  )
7222 
 
594 rajveer 7223 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7224 
    self.userid = userid
594 rajveer 7225 
    self.oldPassword = oldPassword
7226 
    self.newPassword = newPassword
94 ashish 7227 
 
7228 
  def read(self, iprot):
7229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7231 
      return
7232 
    iprot.readStructBegin()
7233 
    while True:
7234 
      (fname, ftype, fid) = iprot.readFieldBegin()
7235 
      if ftype == TType.STOP:
7236 
        break
7237 
      if fid == 1:
7238 
        if ftype == TType.I64:
559 chandransh 7239 
          self.userid = iprot.readI64();
94 ashish 7240 
        else:
7241 
          iprot.skip(ftype)
7242 
      elif fid == 2:
559 chandransh 7243 
        if ftype == TType.STRING:
594 rajveer 7244 
          self.oldPassword = iprot.readString();
94 ashish 7245 
        else:
7246 
          iprot.skip(ftype)
594 rajveer 7247 
      elif fid == 3:
7248 
        if ftype == TType.STRING:
7249 
          self.newPassword = iprot.readString();
7250 
        else:
7251 
          iprot.skip(ftype)
94 ashish 7252 
      else:
7253 
        iprot.skip(ftype)
7254 
      iprot.readFieldEnd()
7255 
    iprot.readStructEnd()
7256 
 
7257 
  def write(self, oprot):
7258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7260 
      return
559 chandransh 7261 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7262 
    if self.userid is not None:
559 chandransh 7263 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7264 
      oprot.writeI64(self.userid)
94 ashish 7265 
      oprot.writeFieldEnd()
3431 rajveer 7266 
    if self.oldPassword is not None:
594 rajveer 7267 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7268 
      oprot.writeString(self.oldPassword)
94 ashish 7269 
      oprot.writeFieldEnd()
3431 rajveer 7270 
    if self.newPassword is not None:
594 rajveer 7271 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7272 
      oprot.writeString(self.newPassword)
7273 
      oprot.writeFieldEnd()
94 ashish 7274 
    oprot.writeFieldStop()
7275 
    oprot.writeStructEnd()
7276 
 
3431 rajveer 7277 
  def validate(self):
7278 
    return
7279 
 
7280 
 
94 ashish 7281 
  def __repr__(self):
7282 
    L = ['%s=%r' % (key, value)
7283 
      for key, value in self.__dict__.iteritems()]
7284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7285 
 
7286 
  def __eq__(self, other):
7287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7288 
 
7289 
  def __ne__(self, other):
7290 
    return not (self == other)
7291 
 
559 chandransh 7292 
class updatePassword_result:
94 ashish 7293 
  """
7294 
  Attributes:
7295 
   - success
7296 
   - ucx
7297 
  """
7298 
 
7299 
  thrift_spec = (
7300 
    (0, TType.BOOL, 'success', None, None, ), # 0
7301 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7302 
  )
7303 
 
7304 
  def __init__(self, success=None, ucx=None,):
7305 
    self.success = success
7306 
    self.ucx = ucx
7307 
 
7308 
  def read(self, iprot):
7309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7311 
      return
7312 
    iprot.readStructBegin()
7313 
    while True:
7314 
      (fname, ftype, fid) = iprot.readFieldBegin()
7315 
      if ftype == TType.STOP:
7316 
        break
7317 
      if fid == 0:
7318 
        if ftype == TType.BOOL:
7319 
          self.success = iprot.readBool();
7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      elif fid == 1:
7323 
        if ftype == TType.STRUCT:
7324 
          self.ucx = UserContextException()
7325 
          self.ucx.read(iprot)
7326 
        else:
7327 
          iprot.skip(ftype)
7328 
      else:
7329 
        iprot.skip(ftype)
7330 
      iprot.readFieldEnd()
7331 
    iprot.readStructEnd()
7332 
 
7333 
  def write(self, oprot):
7334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7336 
      return
559 chandransh 7337 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7338 
    if self.success is not None:
94 ashish 7339 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7340 
      oprot.writeBool(self.success)
7341 
      oprot.writeFieldEnd()
3431 rajveer 7342 
    if self.ucx is not None:
94 ashish 7343 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7344 
      self.ucx.write(oprot)
7345 
      oprot.writeFieldEnd()
7346 
    oprot.writeFieldStop()
7347 
    oprot.writeStructEnd()
7348 
 
3431 rajveer 7349 
  def validate(self):
7350 
    return
7351 
 
7352 
 
94 ashish 7353 
  def __repr__(self):
7354 
    L = ['%s=%r' % (key, value)
7355 
      for key, value in self.__dict__.iteritems()]
7356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7357 
 
7358 
  def __eq__(self, other):
7359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7360 
 
7361 
  def __ne__(self, other):
7362 
    return not (self == other)
7363 
 
581 rajveer 7364 
class forgotPassword_args:
7365 
  """
7366 
  Attributes:
7367 
   - email
884 rajveer 7368 
   - newPassword
581 rajveer 7369 
  """
7370 
 
7371 
  thrift_spec = (
7372 
    None, # 0
7373 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7374 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7375 
  )
7376 
 
884 rajveer 7377 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7378 
    self.email = email
884 rajveer 7379 
    self.newPassword = newPassword
581 rajveer 7380 
 
7381 
  def read(self, iprot):
7382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7384 
      return
7385 
    iprot.readStructBegin()
7386 
    while True:
7387 
      (fname, ftype, fid) = iprot.readFieldBegin()
7388 
      if ftype == TType.STOP:
7389 
        break
7390 
      if fid == 1:
7391 
        if ftype == TType.STRING:
7392 
          self.email = iprot.readString();
7393 
        else:
7394 
          iprot.skip(ftype)
884 rajveer 7395 
      elif fid == 2:
7396 
        if ftype == TType.STRING:
7397 
          self.newPassword = iprot.readString();
7398 
        else:
7399 
          iprot.skip(ftype)
581 rajveer 7400 
      else:
7401 
        iprot.skip(ftype)
7402 
      iprot.readFieldEnd()
7403 
    iprot.readStructEnd()
7404 
 
7405 
  def write(self, oprot):
7406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7408 
      return
7409 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7410 
    if self.email is not None:
581 rajveer 7411 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7412 
      oprot.writeString(self.email)
7413 
      oprot.writeFieldEnd()
3431 rajveer 7414 
    if self.newPassword is not None:
884 rajveer 7415 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7416 
      oprot.writeString(self.newPassword)
7417 
      oprot.writeFieldEnd()
581 rajveer 7418 
    oprot.writeFieldStop()
7419 
    oprot.writeStructEnd()
7420 
 
3431 rajveer 7421 
  def validate(self):
7422 
    return
7423 
 
7424 
 
581 rajveer 7425 
  def __repr__(self):
7426 
    L = ['%s=%r' % (key, value)
7427 
      for key, value in self.__dict__.iteritems()]
7428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7429 
 
7430 
  def __eq__(self, other):
7431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7432 
 
7433 
  def __ne__(self, other):
7434 
    return not (self == other)
7435 
 
7436 
class forgotPassword_result:
7437 
  """
7438 
  Attributes:
7439 
   - success
7440 
   - ucx
7441 
  """
7442 
 
7443 
  thrift_spec = (
7444 
    (0, TType.BOOL, 'success', None, None, ), # 0
7445 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7446 
  )
7447 
 
7448 
  def __init__(self, success=None, ucx=None,):
7449 
    self.success = success
7450 
    self.ucx = ucx
7451 
 
7452 
  def read(self, iprot):
7453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7455 
      return
7456 
    iprot.readStructBegin()
7457 
    while True:
7458 
      (fname, ftype, fid) = iprot.readFieldBegin()
7459 
      if ftype == TType.STOP:
7460 
        break
7461 
      if fid == 0:
7462 
        if ftype == TType.BOOL:
7463 
          self.success = iprot.readBool();
7464 
        else:
7465 
          iprot.skip(ftype)
7466 
      elif fid == 1:
7467 
        if ftype == TType.STRUCT:
7468 
          self.ucx = UserContextException()
7469 
          self.ucx.read(iprot)
7470 
        else:
7471 
          iprot.skip(ftype)
7472 
      else:
7473 
        iprot.skip(ftype)
7474 
      iprot.readFieldEnd()
7475 
    iprot.readStructEnd()
7476 
 
7477 
  def write(self, oprot):
7478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7480 
      return
7481 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7482 
    if self.success is not None:
581 rajveer 7483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7484 
      oprot.writeBool(self.success)
7485 
      oprot.writeFieldEnd()
3431 rajveer 7486 
    if self.ucx is not None:
581 rajveer 7487 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7488 
      self.ucx.write(oprot)
7489 
      oprot.writeFieldEnd()
7490 
    oprot.writeFieldStop()
7491 
    oprot.writeStructEnd()
7492 
 
3431 rajveer 7493 
  def validate(self):
7494 
    return
7495 
 
7496 
 
581 rajveer 7497 
  def __repr__(self):
7498 
    L = ['%s=%r' % (key, value)
7499 
      for key, value in self.__dict__.iteritems()]
7500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7501 
 
7502 
  def __eq__(self, other):
7503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7504 
 
7505 
  def __ne__(self, other):
7506 
    return not (self == other)
7507 
 
594 rajveer 7508 
class getAllAddressesForUser_args:
7509 
  """
7510 
  Attributes:
7511 
   - userId
7512 
  """
7513 
 
7514 
  thrift_spec = (
7515 
    None, # 0
7516 
    (1, TType.I64, 'userId', None, None, ), # 1
7517 
  )
7518 
 
7519 
  def __init__(self, userId=None,):
7520 
    self.userId = userId
7521 
 
7522 
  def read(self, iprot):
7523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7525 
      return
7526 
    iprot.readStructBegin()
7527 
    while True:
7528 
      (fname, ftype, fid) = iprot.readFieldBegin()
7529 
      if ftype == TType.STOP:
7530 
        break
7531 
      if fid == 1:
7532 
        if ftype == TType.I64:
7533 
          self.userId = iprot.readI64();
7534 
        else:
7535 
          iprot.skip(ftype)
7536 
      else:
7537 
        iprot.skip(ftype)
7538 
      iprot.readFieldEnd()
7539 
    iprot.readStructEnd()
7540 
 
7541 
  def write(self, oprot):
7542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7544 
      return
7545 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7546 
    if self.userId is not None:
594 rajveer 7547 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7548 
      oprot.writeI64(self.userId)
7549 
      oprot.writeFieldEnd()
7550 
    oprot.writeFieldStop()
7551 
    oprot.writeStructEnd()
7552 
 
3431 rajveer 7553 
  def validate(self):
7554 
    return
7555 
 
7556 
 
594 rajveer 7557 
  def __repr__(self):
7558 
    L = ['%s=%r' % (key, value)
7559 
      for key, value in self.__dict__.iteritems()]
7560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7561 
 
7562 
  def __eq__(self, other):
7563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7564 
 
7565 
  def __ne__(self, other):
7566 
    return not (self == other)
7567 
 
7568 
class getAllAddressesForUser_result:
7569 
  """
7570 
  Attributes:
7571 
   - success
7572 
   - ucx
7573 
  """
7574 
 
7575 
  thrift_spec = (
7576 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7577 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7578 
  )
7579 
 
7580 
  def __init__(self, success=None, ucx=None,):
7581 
    self.success = success
7582 
    self.ucx = ucx
7583 
 
7584 
  def read(self, iprot):
7585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7587 
      return
7588 
    iprot.readStructBegin()
7589 
    while True:
7590 
      (fname, ftype, fid) = iprot.readFieldBegin()
7591 
      if ftype == TType.STOP:
7592 
        break
7593 
      if fid == 0:
7594 
        if ftype == TType.LIST:
7595 
          self.success = []
11592 amit.gupta 7596 
          (_etype100, _size97) = iprot.readListBegin()
7597 
          for _i101 in xrange(_size97):
7598 
            _elem102 = Address()
7599 
            _elem102.read(iprot)
7600 
            self.success.append(_elem102)
594 rajveer 7601 
          iprot.readListEnd()
7602 
        else:
7603 
          iprot.skip(ftype)
7604 
      elif fid == 1:
7605 
        if ftype == TType.STRUCT:
7606 
          self.ucx = UserContextException()
7607 
          self.ucx.read(iprot)
7608 
        else:
7609 
          iprot.skip(ftype)
7610 
      else:
7611 
        iprot.skip(ftype)
7612 
      iprot.readFieldEnd()
7613 
    iprot.readStructEnd()
7614 
 
7615 
  def write(self, oprot):
7616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7618 
      return
7619 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7620 
    if self.success is not None:
594 rajveer 7621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7622 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7623 
      for iter103 in self.success:
7624 
        iter103.write(oprot)
594 rajveer 7625 
      oprot.writeListEnd()
7626 
      oprot.writeFieldEnd()
3431 rajveer 7627 
    if self.ucx is not None:
594 rajveer 7628 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7629 
      self.ucx.write(oprot)
7630 
      oprot.writeFieldEnd()
7631 
    oprot.writeFieldStop()
7632 
    oprot.writeStructEnd()
7633 
 
3431 rajveer 7634 
  def validate(self):
7635 
    return
7636 
 
7637 
 
594 rajveer 7638 
  def __repr__(self):
7639 
    L = ['%s=%r' % (key, value)
7640 
      for key, value in self.__dict__.iteritems()]
7641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7642 
 
7643 
  def __eq__(self, other):
7644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7645 
 
7646 
  def __ne__(self, other):
7647 
    return not (self == other)
7648 
 
1894 vikas 7649 
class getAddressById_args:
7650 
  """
7651 
  Attributes:
7652 
   - addressId
7653 
  """
7654 
 
7655 
  thrift_spec = (
7656 
    None, # 0
7657 
    (1, TType.I64, 'addressId', None, None, ), # 1
7658 
  )
7659 
 
7660 
  def __init__(self, addressId=None,):
7661 
    self.addressId = addressId
7662 
 
7663 
  def read(self, iprot):
7664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7666 
      return
7667 
    iprot.readStructBegin()
7668 
    while True:
7669 
      (fname, ftype, fid) = iprot.readFieldBegin()
7670 
      if ftype == TType.STOP:
7671 
        break
7672 
      if fid == 1:
7673 
        if ftype == TType.I64:
7674 
          self.addressId = iprot.readI64();
7675 
        else:
7676 
          iprot.skip(ftype)
7677 
      else:
7678 
        iprot.skip(ftype)
7679 
      iprot.readFieldEnd()
7680 
    iprot.readStructEnd()
7681 
 
7682 
  def write(self, oprot):
7683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7685 
      return
7686 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7687 
    if self.addressId is not None:
1894 vikas 7688 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7689 
      oprot.writeI64(self.addressId)
7690 
      oprot.writeFieldEnd()
7691 
    oprot.writeFieldStop()
7692 
    oprot.writeStructEnd()
7693 
 
3431 rajveer 7694 
  def validate(self):
7695 
    return
7696 
 
7697 
 
1894 vikas 7698 
  def __repr__(self):
7699 
    L = ['%s=%r' % (key, value)
7700 
      for key, value in self.__dict__.iteritems()]
7701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7702 
 
7703 
  def __eq__(self, other):
7704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7705 
 
7706 
  def __ne__(self, other):
7707 
    return not (self == other)
7708 
 
7709 
class getAddressById_result:
7710 
  """
7711 
  Attributes:
7712 
   - success
7713 
   - ucx
7714 
  """
7715 
 
7716 
  thrift_spec = (
7717 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7718 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7719 
  )
7720 
 
7721 
  def __init__(self, success=None, ucx=None,):
7722 
    self.success = success
7723 
    self.ucx = ucx
7724 
 
7725 
  def read(self, iprot):
7726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7728 
      return
7729 
    iprot.readStructBegin()
7730 
    while True:
7731 
      (fname, ftype, fid) = iprot.readFieldBegin()
7732 
      if ftype == TType.STOP:
7733 
        break
7734 
      if fid == 0:
7735 
        if ftype == TType.STRUCT:
7736 
          self.success = Address()
7737 
          self.success.read(iprot)
7738 
        else:
7739 
          iprot.skip(ftype)
7740 
      elif fid == 1:
7741 
        if ftype == TType.STRUCT:
7742 
          self.ucx = UserContextException()
7743 
          self.ucx.read(iprot)
7744 
        else:
7745 
          iprot.skip(ftype)
7746 
      else:
7747 
        iprot.skip(ftype)
7748 
      iprot.readFieldEnd()
7749 
    iprot.readStructEnd()
7750 
 
7751 
  def write(self, oprot):
7752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7754 
      return
7755 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7756 
    if self.success is not None:
1894 vikas 7757 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7758 
      self.success.write(oprot)
7759 
      oprot.writeFieldEnd()
3431 rajveer 7760 
    if self.ucx is not None:
1894 vikas 7761 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7762 
      self.ucx.write(oprot)
7763 
      oprot.writeFieldEnd()
7764 
    oprot.writeFieldStop()
7765 
    oprot.writeStructEnd()
7766 
 
3431 rajveer 7767 
  def validate(self):
7768 
    return
7769 
 
7770 
 
1894 vikas 7771 
  def __repr__(self):
7772 
    L = ['%s=%r' % (key, value)
7773 
      for key, value in self.__dict__.iteritems()]
7774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7775 
 
7776 
  def __eq__(self, other):
7777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7778 
 
7779 
  def __ne__(self, other):
7780 
    return not (self == other)
7781 
 
594 rajveer 7782 
class getDefaultAddressId_args:
7783 
  """
7784 
  Attributes:
7785 
   - userId
7786 
  """
7787 
 
7788 
  thrift_spec = (
7789 
    None, # 0
7790 
    (1, TType.I64, 'userId', None, None, ), # 1
7791 
  )
7792 
 
7793 
  def __init__(self, userId=None,):
7794 
    self.userId = userId
7795 
 
7796 
  def read(self, iprot):
7797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7799 
      return
7800 
    iprot.readStructBegin()
7801 
    while True:
7802 
      (fname, ftype, fid) = iprot.readFieldBegin()
7803 
      if ftype == TType.STOP:
7804 
        break
7805 
      if fid == 1:
7806 
        if ftype == TType.I64:
7807 
          self.userId = iprot.readI64();
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
7819 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7820 
    if self.userId is not None:
594 rajveer 7821 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7822 
      oprot.writeI64(self.userId)
7823 
      oprot.writeFieldEnd()
7824 
    oprot.writeFieldStop()
7825 
    oprot.writeStructEnd()
7826 
 
3431 rajveer 7827 
  def validate(self):
7828 
    return
7829 
 
7830 
 
594 rajveer 7831 
  def __repr__(self):
7832 
    L = ['%s=%r' % (key, value)
7833 
      for key, value in self.__dict__.iteritems()]
7834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7835 
 
7836 
  def __eq__(self, other):
7837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7838 
 
7839 
  def __ne__(self, other):
7840 
    return not (self == other)
7841 
 
7842 
class getDefaultAddressId_result:
7843 
  """
7844 
  Attributes:
7845 
   - success
7846 
   - ucx
7847 
  """
7848 
 
7849 
  thrift_spec = (
7850 
    (0, TType.I64, 'success', None, None, ), # 0
7851 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7852 
  )
7853 
 
7854 
  def __init__(self, success=None, ucx=None,):
7855 
    self.success = success
7856 
    self.ucx = ucx
7857 
 
7858 
  def read(self, iprot):
7859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7861 
      return
7862 
    iprot.readStructBegin()
7863 
    while True:
7864 
      (fname, ftype, fid) = iprot.readFieldBegin()
7865 
      if ftype == TType.STOP:
7866 
        break
7867 
      if fid == 0:
7868 
        if ftype == TType.I64:
7869 
          self.success = iprot.readI64();
7870 
        else:
7871 
          iprot.skip(ftype)
7872 
      elif fid == 1:
7873 
        if ftype == TType.STRUCT:
7874 
          self.ucx = UserContextException()
7875 
          self.ucx.read(iprot)
7876 
        else:
7877 
          iprot.skip(ftype)
7878 
      else:
7879 
        iprot.skip(ftype)
7880 
      iprot.readFieldEnd()
7881 
    iprot.readStructEnd()
7882 
 
7883 
  def write(self, oprot):
7884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7886 
      return
7887 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7888 
    if self.success is not None:
594 rajveer 7889 
      oprot.writeFieldBegin('success', TType.I64, 0)
7890 
      oprot.writeI64(self.success)
7891 
      oprot.writeFieldEnd()
3431 rajveer 7892 
    if self.ucx is not None:
594 rajveer 7893 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7894 
      self.ucx.write(oprot)
7895 
      oprot.writeFieldEnd()
7896 
    oprot.writeFieldStop()
7897 
    oprot.writeStructEnd()
7898 
 
3431 rajveer 7899 
  def validate(self):
7900 
    return
7901 
 
7902 
 
594 rajveer 7903 
  def __repr__(self):
7904 
    L = ['%s=%r' % (key, value)
7905 
      for key, value in self.__dict__.iteritems()]
7906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7907 
 
7908 
  def __eq__(self, other):
7909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7910 
 
7911 
  def __ne__(self, other):
7912 
    return not (self == other)
7913 
 
785 rajveer 7914 
class getDefaultPincode_args:
7915 
  """
7916 
  Attributes:
7917 
   - userId
7918 
  """
7919 
 
7920 
  thrift_spec = (
7921 
    None, # 0
7922 
    (1, TType.I64, 'userId', None, None, ), # 1
7923 
  )
7924 
 
7925 
  def __init__(self, userId=None,):
7926 
    self.userId = userId
7927 
 
7928 
  def read(self, iprot):
7929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7931 
      return
7932 
    iprot.readStructBegin()
7933 
    while True:
7934 
      (fname, ftype, fid) = iprot.readFieldBegin()
7935 
      if ftype == TType.STOP:
7936 
        break
7937 
      if fid == 1:
7938 
        if ftype == TType.I64:
7939 
          self.userId = iprot.readI64();
7940 
        else:
7941 
          iprot.skip(ftype)
7942 
      else:
7943 
        iprot.skip(ftype)
7944 
      iprot.readFieldEnd()
7945 
    iprot.readStructEnd()
7946 
 
7947 
  def write(self, oprot):
7948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7950 
      return
7951 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7952 
    if self.userId is not None:
785 rajveer 7953 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7954 
      oprot.writeI64(self.userId)
7955 
      oprot.writeFieldEnd()
7956 
    oprot.writeFieldStop()
7957 
    oprot.writeStructEnd()
7958 
 
3431 rajveer 7959 
  def validate(self):
7960 
    return
7961 
 
7962 
 
785 rajveer 7963 
  def __repr__(self):
7964 
    L = ['%s=%r' % (key, value)
7965 
      for key, value in self.__dict__.iteritems()]
7966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7967 
 
7968 
  def __eq__(self, other):
7969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7970 
 
7971 
  def __ne__(self, other):
7972 
    return not (self == other)
7973 
 
7974 
class getDefaultPincode_result:
7975 
  """
7976 
  Attributes:
7977 
   - success
7978 
   - ucx
7979 
  """
7980 
 
7981 
  thrift_spec = (
7982 
    (0, TType.STRING, 'success', None, None, ), # 0
7983 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7984 
  )
7985 
 
7986 
  def __init__(self, success=None, ucx=None,):
7987 
    self.success = success
7988 
    self.ucx = ucx
7989 
 
7990 
  def read(self, iprot):
7991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7993 
      return
7994 
    iprot.readStructBegin()
7995 
    while True:
7996 
      (fname, ftype, fid) = iprot.readFieldBegin()
7997 
      if ftype == TType.STOP:
7998 
        break
7999 
      if fid == 0:
8000 
        if ftype == TType.STRING:
8001 
          self.success = iprot.readString();
8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 1:
8005 
        if ftype == TType.STRUCT:
8006 
          self.ucx = UserContextException()
8007 
          self.ucx.read(iprot)
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      else:
8011 
        iprot.skip(ftype)
8012 
      iprot.readFieldEnd()
8013 
    iprot.readStructEnd()
8014 
 
8015 
  def write(self, oprot):
8016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8018 
      return
8019 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 8020 
    if self.success is not None:
785 rajveer 8021 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8022 
      oprot.writeString(self.success)
8023 
      oprot.writeFieldEnd()
3431 rajveer 8024 
    if self.ucx is not None:
785 rajveer 8025 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8026 
      self.ucx.write(oprot)
8027 
      oprot.writeFieldEnd()
8028 
    oprot.writeFieldStop()
8029 
    oprot.writeStructEnd()
8030 
 
3431 rajveer 8031 
  def validate(self):
8032 
    return
8033 
 
8034 
 
785 rajveer 8035 
  def __repr__(self):
8036 
    L = ['%s=%r' % (key, value)
8037 
      for key, value in self.__dict__.iteritems()]
8038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8039 
 
8040 
  def __eq__(self, other):
8041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8042 
 
8043 
  def __ne__(self, other):
8044 
    return not (self == other)
8045 
 
1274 varun.gupt 8046 
class saveUserCommunication_args:
8047 
  """
8048 
  Attributes:
8049 
   - userId
8050 
   - replyTo
8051 
   - communicationType
8052 
   - orderId
8053 
   - airwaybillNo
8054 
   - productName
8055 
   - subject
8056 
   - message
8057 
  """
8058 
 
8059 
  thrift_spec = (
8060 
    None, # 0
8061 
    (1, TType.I64, 'userId', None, None, ), # 1
8062 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
8063 
    (3, TType.I64, 'communicationType', None, None, ), # 3
8064 
    (4, TType.I64, 'orderId', None, None, ), # 4
8065 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
8066 
    (6, TType.STRING, 'productName', None, None, ), # 6
8067 
    (7, TType.STRING, 'subject', None, None, ), # 7
8068 
    (8, TType.STRING, 'message', None, None, ), # 8
8069 
  )
8070 
 
8071 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
8072 
    self.userId = userId
8073 
    self.replyTo = replyTo
8074 
    self.communicationType = communicationType
8075 
    self.orderId = orderId
8076 
    self.airwaybillNo = airwaybillNo
8077 
    self.productName = productName
8078 
    self.subject = subject
8079 
    self.message = message
8080 
 
8081 
  def read(self, iprot):
8082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8084 
      return
8085 
    iprot.readStructBegin()
8086 
    while True:
8087 
      (fname, ftype, fid) = iprot.readFieldBegin()
8088 
      if ftype == TType.STOP:
8089 
        break
8090 
      if fid == 1:
8091 
        if ftype == TType.I64:
8092 
          self.userId = iprot.readI64();
8093 
        else:
8094 
          iprot.skip(ftype)
8095 
      elif fid == 2:
8096 
        if ftype == TType.STRING:
8097 
          self.replyTo = iprot.readString();
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      elif fid == 3:
8101 
        if ftype == TType.I64:
8102 
          self.communicationType = iprot.readI64();
8103 
        else:
8104 
          iprot.skip(ftype)
8105 
      elif fid == 4:
8106 
        if ftype == TType.I64:
8107 
          self.orderId = iprot.readI64();
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 5:
8111 
        if ftype == TType.STRING:
8112 
          self.airwaybillNo = iprot.readString();
8113 
        else:
8114 
          iprot.skip(ftype)
8115 
      elif fid == 6:
8116 
        if ftype == TType.STRING:
8117 
          self.productName = iprot.readString();
8118 
        else:
8119 
          iprot.skip(ftype)
8120 
      elif fid == 7:
8121 
        if ftype == TType.STRING:
8122 
          self.subject = iprot.readString();
8123 
        else:
8124 
          iprot.skip(ftype)
8125 
      elif fid == 8:
8126 
        if ftype == TType.STRING:
8127 
          self.message = iprot.readString();
8128 
        else:
8129 
          iprot.skip(ftype)
8130 
      else:
8131 
        iprot.skip(ftype)
8132 
      iprot.readFieldEnd()
8133 
    iprot.readStructEnd()
8134 
 
8135 
  def write(self, oprot):
8136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8138 
      return
8139 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8140 
    if self.userId is not None:
1274 varun.gupt 8141 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8142 
      oprot.writeI64(self.userId)
8143 
      oprot.writeFieldEnd()
3431 rajveer 8144 
    if self.replyTo is not None:
1274 varun.gupt 8145 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8146 
      oprot.writeString(self.replyTo)
8147 
      oprot.writeFieldEnd()
3431 rajveer 8148 
    if self.communicationType is not None:
1274 varun.gupt 8149 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8150 
      oprot.writeI64(self.communicationType)
8151 
      oprot.writeFieldEnd()
3431 rajveer 8152 
    if self.orderId is not None:
1274 varun.gupt 8153 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8154 
      oprot.writeI64(self.orderId)
8155 
      oprot.writeFieldEnd()
3431 rajveer 8156 
    if self.airwaybillNo is not None:
1274 varun.gupt 8157 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8158 
      oprot.writeString(self.airwaybillNo)
8159 
      oprot.writeFieldEnd()
3431 rajveer 8160 
    if self.productName is not None:
1274 varun.gupt 8161 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8162 
      oprot.writeString(self.productName)
8163 
      oprot.writeFieldEnd()
3431 rajveer 8164 
    if self.subject is not None:
1274 varun.gupt 8165 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8166 
      oprot.writeString(self.subject)
8167 
      oprot.writeFieldEnd()
3431 rajveer 8168 
    if self.message is not None:
1274 varun.gupt 8169 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8170 
      oprot.writeString(self.message)
8171 
      oprot.writeFieldEnd()
8172 
    oprot.writeFieldStop()
8173 
    oprot.writeStructEnd()
8174 
 
3431 rajveer 8175 
  def validate(self):
8176 
    return
8177 
 
8178 
 
1274 varun.gupt 8179 
  def __repr__(self):
8180 
    L = ['%s=%r' % (key, value)
8181 
      for key, value in self.__dict__.iteritems()]
8182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8183 
 
8184 
  def __eq__(self, other):
8185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8186 
 
8187 
  def __ne__(self, other):
8188 
    return not (self == other)
8189 
 
8190 
class saveUserCommunication_result:
8191 
  """
8192 
  Attributes:
8193 
   - success
8194 
   - ucx
8195 
  """
8196 
 
8197 
  thrift_spec = (
8198 
    (0, TType.BOOL, 'success', None, None, ), # 0
8199 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8200 
  )
8201 
 
8202 
  def __init__(self, success=None, ucx=None,):
8203 
    self.success = success
8204 
    self.ucx = ucx
8205 
 
8206 
  def read(self, iprot):
8207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8209 
      return
8210 
    iprot.readStructBegin()
8211 
    while True:
8212 
      (fname, ftype, fid) = iprot.readFieldBegin()
8213 
      if ftype == TType.STOP:
8214 
        break
8215 
      if fid == 0:
8216 
        if ftype == TType.BOOL:
8217 
          self.success = iprot.readBool();
8218 
        else:
8219 
          iprot.skip(ftype)
8220 
      elif fid == 1:
8221 
        if ftype == TType.STRUCT:
8222 
          self.ucx = UserCommunicationException()
8223 
          self.ucx.read(iprot)
8224 
        else:
8225 
          iprot.skip(ftype)
8226 
      else:
8227 
        iprot.skip(ftype)
8228 
      iprot.readFieldEnd()
8229 
    iprot.readStructEnd()
8230 
 
8231 
  def write(self, oprot):
8232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8234 
      return
8235 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8236 
    if self.success is not None:
1274 varun.gupt 8237 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8238 
      oprot.writeBool(self.success)
8239 
      oprot.writeFieldEnd()
3431 rajveer 8240 
    if self.ucx is not None:
1274 varun.gupt 8241 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8242 
      self.ucx.write(oprot)
8243 
      oprot.writeFieldEnd()
8244 
    oprot.writeFieldStop()
8245 
    oprot.writeStructEnd()
8246 
 
3431 rajveer 8247 
  def validate(self):
8248 
    return
8249 
 
8250 
 
1274 varun.gupt 8251 
  def __repr__(self):
8252 
    L = ['%s=%r' % (key, value)
8253 
      for key, value in self.__dict__.iteritems()]
8254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8255 
 
8256 
  def __eq__(self, other):
8257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8258 
 
8259 
  def __ne__(self, other):
8260 
    return not (self == other)
8261 
 
1590 varun.gupt 8262 
class getUserCommunicationById_args:
8263 
  """
8264 
  Attributes:
8265 
   - id
8266 
  """
8267 
 
8268 
  thrift_spec = (
8269 
    None, # 0
8270 
    (1, TType.I64, 'id', None, None, ), # 1
8271 
  )
8272 
 
8273 
  def __init__(self, id=None,):
8274 
    self.id = id
8275 
 
8276 
  def read(self, iprot):
8277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8279 
      return
8280 
    iprot.readStructBegin()
8281 
    while True:
8282 
      (fname, ftype, fid) = iprot.readFieldBegin()
8283 
      if ftype == TType.STOP:
8284 
        break
8285 
      if fid == 1:
8286 
        if ftype == TType.I64:
8287 
          self.id = iprot.readI64();
8288 
        else:
8289 
          iprot.skip(ftype)
8290 
      else:
8291 
        iprot.skip(ftype)
8292 
      iprot.readFieldEnd()
8293 
    iprot.readStructEnd()
8294 
 
8295 
  def write(self, oprot):
8296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8298 
      return
8299 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8300 
    if self.id is not None:
1590 varun.gupt 8301 
      oprot.writeFieldBegin('id', TType.I64, 1)
8302 
      oprot.writeI64(self.id)
8303 
      oprot.writeFieldEnd()
8304 
    oprot.writeFieldStop()
8305 
    oprot.writeStructEnd()
8306 
 
3431 rajveer 8307 
  def validate(self):
8308 
    return
8309 
 
8310 
 
1590 varun.gupt 8311 
  def __repr__(self):
8312 
    L = ['%s=%r' % (key, value)
8313 
      for key, value in self.__dict__.iteritems()]
8314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8315 
 
8316 
  def __eq__(self, other):
8317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8318 
 
8319 
  def __ne__(self, other):
8320 
    return not (self == other)
8321 
 
8322 
class getUserCommunicationById_result:
8323 
  """
8324 
  Attributes:
8325 
   - success
8326 
   - ucx
8327 
  """
8328 
 
8329 
  thrift_spec = (
8330 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8331 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8332 
  )
8333 
 
8334 
  def __init__(self, success=None, ucx=None,):
8335 
    self.success = success
8336 
    self.ucx = ucx
8337 
 
8338 
  def read(self, iprot):
8339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8341 
      return
8342 
    iprot.readStructBegin()
8343 
    while True:
8344 
      (fname, ftype, fid) = iprot.readFieldBegin()
8345 
      if ftype == TType.STOP:
8346 
        break
8347 
      if fid == 0:
8348 
        if ftype == TType.STRUCT:
8349 
          self.success = UserCommunication()
8350 
          self.success.read(iprot)
8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      elif fid == 1:
8354 
        if ftype == TType.STRUCT:
8355 
          self.ucx = UserCommunicationException()
8356 
          self.ucx.read(iprot)
8357 
        else:
8358 
          iprot.skip(ftype)
8359 
      else:
8360 
        iprot.skip(ftype)
8361 
      iprot.readFieldEnd()
8362 
    iprot.readStructEnd()
8363 
 
8364 
  def write(self, oprot):
8365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8367 
      return
8368 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8369 
    if self.success is not None:
1590 varun.gupt 8370 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8371 
      self.success.write(oprot)
8372 
      oprot.writeFieldEnd()
3431 rajveer 8373 
    if self.ucx is not None:
1590 varun.gupt 8374 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8375 
      self.ucx.write(oprot)
8376 
      oprot.writeFieldEnd()
8377 
    oprot.writeFieldStop()
8378 
    oprot.writeStructEnd()
8379 
 
3431 rajveer 8380 
  def validate(self):
8381 
    return
8382 
 
8383 
 
1590 varun.gupt 8384 
  def __repr__(self):
8385 
    L = ['%s=%r' % (key, value)
8386 
      for key, value in self.__dict__.iteritems()]
8387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8388 
 
8389 
  def __eq__(self, other):
8390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8391 
 
8392 
  def __ne__(self, other):
8393 
    return not (self == other)
8394 
 
8395 
class getUserCommunicationByUser_args:
8396 
  """
8397 
  Attributes:
8398 
   - userId
8399 
  """
8400 
 
8401 
  thrift_spec = (
8402 
    None, # 0
8403 
    (1, TType.I64, 'userId', None, None, ), # 1
8404 
  )
8405 
 
8406 
  def __init__(self, userId=None,):
8407 
    self.userId = userId
8408 
 
8409 
  def read(self, iprot):
8410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8412 
      return
8413 
    iprot.readStructBegin()
8414 
    while True:
8415 
      (fname, ftype, fid) = iprot.readFieldBegin()
8416 
      if ftype == TType.STOP:
8417 
        break
8418 
      if fid == 1:
8419 
        if ftype == TType.I64:
8420 
          self.userId = iprot.readI64();
8421 
        else:
8422 
          iprot.skip(ftype)
8423 
      else:
8424 
        iprot.skip(ftype)
8425 
      iprot.readFieldEnd()
8426 
    iprot.readStructEnd()
8427 
 
8428 
  def write(self, oprot):
8429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8431 
      return
8432 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8433 
    if self.userId is not None:
1590 varun.gupt 8434 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8435 
      oprot.writeI64(self.userId)
8436 
      oprot.writeFieldEnd()
8437 
    oprot.writeFieldStop()
8438 
    oprot.writeStructEnd()
8439 
 
3431 rajveer 8440 
  def validate(self):
8441 
    return
8442 
 
8443 
 
1590 varun.gupt 8444 
  def __repr__(self):
8445 
    L = ['%s=%r' % (key, value)
8446 
      for key, value in self.__dict__.iteritems()]
8447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8448 
 
8449 
  def __eq__(self, other):
8450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8451 
 
8452 
  def __ne__(self, other):
8453 
    return not (self == other)
8454 
 
8455 
class getUserCommunicationByUser_result:
8456 
  """
8457 
  Attributes:
8458 
   - success
8459 
   - ucx
8460 
  """
8461 
 
8462 
  thrift_spec = (
8463 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8464 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8465 
  )
8466 
 
8467 
  def __init__(self, success=None, ucx=None,):
8468 
    self.success = success
8469 
    self.ucx = ucx
8470 
 
8471 
  def read(self, iprot):
8472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8474 
      return
8475 
    iprot.readStructBegin()
8476 
    while True:
8477 
      (fname, ftype, fid) = iprot.readFieldBegin()
8478 
      if ftype == TType.STOP:
8479 
        break
8480 
      if fid == 0:
8481 
        if ftype == TType.LIST:
8482 
          self.success = []
11592 amit.gupta 8483 
          (_etype107, _size104) = iprot.readListBegin()
8484 
          for _i108 in xrange(_size104):
8485 
            _elem109 = UserCommunication()
8486 
            _elem109.read(iprot)
8487 
            self.success.append(_elem109)
1590 varun.gupt 8488 
          iprot.readListEnd()
8489 
        else:
8490 
          iprot.skip(ftype)
8491 
      elif fid == 1:
8492 
        if ftype == TType.STRUCT:
8493 
          self.ucx = UserCommunicationException()
8494 
          self.ucx.read(iprot)
8495 
        else:
8496 
          iprot.skip(ftype)
8497 
      else:
8498 
        iprot.skip(ftype)
8499 
      iprot.readFieldEnd()
8500 
    iprot.readStructEnd()
8501 
 
8502 
  def write(self, oprot):
8503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8505 
      return
8506 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8507 
    if self.success is not None:
1590 varun.gupt 8508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8510 
      for iter110 in self.success:
8511 
        iter110.write(oprot)
1590 varun.gupt 8512 
      oprot.writeListEnd()
8513 
      oprot.writeFieldEnd()
3431 rajveer 8514 
    if self.ucx is not None:
1590 varun.gupt 8515 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8516 
      self.ucx.write(oprot)
8517 
      oprot.writeFieldEnd()
8518 
    oprot.writeFieldStop()
8519 
    oprot.writeStructEnd()
8520 
 
3431 rajveer 8521 
  def validate(self):
8522 
    return
8523 
 
8524 
 
1590 varun.gupt 8525 
  def __repr__(self):
8526 
    L = ['%s=%r' % (key, value)
8527 
      for key, value in self.__dict__.iteritems()]
8528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8529 
 
8530 
  def __eq__(self, other):
8531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8532 
 
8533 
  def __ne__(self, other):
8534 
    return not (self == other)
8535 
 
8536 
class getAllUserCommunications_args:
8537 
 
8538 
  thrift_spec = (
8539 
  )
8540 
 
8541 
  def read(self, iprot):
8542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8544 
      return
8545 
    iprot.readStructBegin()
8546 
    while True:
8547 
      (fname, ftype, fid) = iprot.readFieldBegin()
8548 
      if ftype == TType.STOP:
8549 
        break
8550 
      else:
8551 
        iprot.skip(ftype)
8552 
      iprot.readFieldEnd()
8553 
    iprot.readStructEnd()
8554 
 
8555 
  def write(self, oprot):
8556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8558 
      return
8559 
    oprot.writeStructBegin('getAllUserCommunications_args')
8560 
    oprot.writeFieldStop()
8561 
    oprot.writeStructEnd()
8562 
 
3431 rajveer 8563 
  def validate(self):
8564 
    return
8565 
 
8566 
 
1590 varun.gupt 8567 
  def __repr__(self):
8568 
    L = ['%s=%r' % (key, value)
8569 
      for key, value in self.__dict__.iteritems()]
8570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8571 
 
8572 
  def __eq__(self, other):
8573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8574 
 
8575 
  def __ne__(self, other):
8576 
    return not (self == other)
8577 
 
8578 
class getAllUserCommunications_result:
8579 
  """
8580 
  Attributes:
8581 
   - success
8582 
   - ucx
8583 
  """
8584 
 
8585 
  thrift_spec = (
8586 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8587 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8588 
  )
8589 
 
8590 
  def __init__(self, success=None, ucx=None,):
8591 
    self.success = success
8592 
    self.ucx = ucx
8593 
 
8594 
  def read(self, iprot):
8595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8597 
      return
8598 
    iprot.readStructBegin()
8599 
    while True:
8600 
      (fname, ftype, fid) = iprot.readFieldBegin()
8601 
      if ftype == TType.STOP:
8602 
        break
8603 
      if fid == 0:
8604 
        if ftype == TType.LIST:
8605 
          self.success = []
11592 amit.gupta 8606 
          (_etype114, _size111) = iprot.readListBegin()
8607 
          for _i115 in xrange(_size111):
8608 
            _elem116 = UserCommunication()
8609 
            _elem116.read(iprot)
8610 
            self.success.append(_elem116)
1590 varun.gupt 8611 
          iprot.readListEnd()
8612 
        else:
8613 
          iprot.skip(ftype)
8614 
      elif fid == 1:
8615 
        if ftype == TType.STRUCT:
8616 
          self.ucx = UserCommunicationException()
8617 
          self.ucx.read(iprot)
8618 
        else:
8619 
          iprot.skip(ftype)
8620 
      else:
8621 
        iprot.skip(ftype)
8622 
      iprot.readFieldEnd()
8623 
    iprot.readStructEnd()
8624 
 
8625 
  def write(self, oprot):
8626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8628 
      return
8629 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8630 
    if self.success is not None:
1590 varun.gupt 8631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8633 
      for iter117 in self.success:
8634 
        iter117.write(oprot)
1590 varun.gupt 8635 
      oprot.writeListEnd()
8636 
      oprot.writeFieldEnd()
3431 rajveer 8637 
    if self.ucx is not None:
1590 varun.gupt 8638 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8639 
      self.ucx.write(oprot)
8640 
      oprot.writeFieldEnd()
8641 
    oprot.writeFieldStop()
8642 
    oprot.writeStructEnd()
8643 
 
3431 rajveer 8644 
  def validate(self):
8645 
    return
8646 
 
8647 
 
1590 varun.gupt 8648 
  def __repr__(self):
8649 
    L = ['%s=%r' % (key, value)
8650 
      for key, value in self.__dict__.iteritems()]
8651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8652 
 
8653 
  def __eq__(self, other):
8654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8655 
 
8656 
  def __ne__(self, other):
8657 
    return not (self == other)
8658 
 
5407 amar.kumar 8659 
class removeUserCommunication_args:
8660 
  """
8661 
  Attributes:
8662 
   - id
8663 
  """
8664 
 
8665 
  thrift_spec = (
8666 
    None, # 0
8667 
    (1, TType.I64, 'id', None, None, ), # 1
8668 
  )
8669 
 
8670 
  def __init__(self, id=None,):
8671 
    self.id = id
8672 
 
8673 
  def read(self, iprot):
8674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8676 
      return
8677 
    iprot.readStructBegin()
8678 
    while True:
8679 
      (fname, ftype, fid) = iprot.readFieldBegin()
8680 
      if ftype == TType.STOP:
8681 
        break
8682 
      if fid == 1:
8683 
        if ftype == TType.I64:
8684 
          self.id = iprot.readI64();
8685 
        else:
8686 
          iprot.skip(ftype)
8687 
      else:
8688 
        iprot.skip(ftype)
8689 
      iprot.readFieldEnd()
8690 
    iprot.readStructEnd()
8691 
 
8692 
  def write(self, oprot):
8693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8695 
      return
8696 
    oprot.writeStructBegin('removeUserCommunication_args')
8697 
    if self.id is not None:
8698 
      oprot.writeFieldBegin('id', TType.I64, 1)
8699 
      oprot.writeI64(self.id)
8700 
      oprot.writeFieldEnd()
8701 
    oprot.writeFieldStop()
8702 
    oprot.writeStructEnd()
8703 
 
8704 
  def validate(self):
8705 
    return
8706 
 
8707 
 
8708 
  def __repr__(self):
8709 
    L = ['%s=%r' % (key, value)
8710 
      for key, value in self.__dict__.iteritems()]
8711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8712 
 
8713 
  def __eq__(self, other):
8714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8715 
 
8716 
  def __ne__(self, other):
8717 
    return not (self == other)
8718 
 
8719 
class removeUserCommunication_result:
8720 
  """
8721 
  Attributes:
8722 
   - ucx
8723 
  """
8724 
 
8725 
  thrift_spec = (
8726 
    None, # 0
8727 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8728 
  )
8729 
 
8730 
  def __init__(self, ucx=None,):
8731 
    self.ucx = ucx
8732 
 
8733 
  def read(self, iprot):
8734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8736 
      return
8737 
    iprot.readStructBegin()
8738 
    while True:
8739 
      (fname, ftype, fid) = iprot.readFieldBegin()
8740 
      if ftype == TType.STOP:
8741 
        break
8742 
      if fid == 1:
8743 
        if ftype == TType.STRUCT:
8744 
          self.ucx = UserCommunicationException()
8745 
          self.ucx.read(iprot)
8746 
        else:
8747 
          iprot.skip(ftype)
8748 
      else:
8749 
        iprot.skip(ftype)
8750 
      iprot.readFieldEnd()
8751 
    iprot.readStructEnd()
8752 
 
8753 
  def write(self, oprot):
8754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8756 
      return
8757 
    oprot.writeStructBegin('removeUserCommunication_result')
8758 
    if self.ucx is not None:
8759 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8760 
      self.ucx.write(oprot)
8761 
      oprot.writeFieldEnd()
8762 
    oprot.writeFieldStop()
8763 
    oprot.writeStructEnd()
8764 
 
8765 
  def validate(self):
8766 
    return
8767 
 
8768 
 
8769 
  def __repr__(self):
8770 
    L = ['%s=%r' % (key, value)
8771 
      for key, value in self.__dict__.iteritems()]
8772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8773 
 
8774 
  def __eq__(self, other):
8775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8776 
 
8777 
  def __ne__(self, other):
8778 
    return not (self == other)
8779 
 
1845 vikas 8780 
class createMasterAffiliate_args:
8781 
  """
8782 
  Attributes:
8783 
   - name
1859 vikas 8784 
   - addedOn
1845 vikas 8785 
  """
8786 
 
8787 
  thrift_spec = (
8788 
    None, # 0
8789 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8790 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8791 
  )
8792 
 
1859 vikas 8793 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8794 
    self.name = name
1859 vikas 8795 
    self.addedOn = addedOn
1845 vikas 8796 
 
8797 
  def read(self, iprot):
8798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8800 
      return
8801 
    iprot.readStructBegin()
8802 
    while True:
8803 
      (fname, ftype, fid) = iprot.readFieldBegin()
8804 
      if ftype == TType.STOP:
8805 
        break
8806 
      if fid == 1:
8807 
        if ftype == TType.STRING:
8808 
          self.name = iprot.readString();
8809 
        else:
8810 
          iprot.skip(ftype)
1859 vikas 8811 
      elif fid == 2:
8812 
        if ftype == TType.I64:
8813 
          self.addedOn = iprot.readI64();
8814 
        else:
8815 
          iprot.skip(ftype)
1845 vikas 8816 
      else:
8817 
        iprot.skip(ftype)
8818 
      iprot.readFieldEnd()
8819 
    iprot.readStructEnd()
8820 
 
8821 
  def write(self, oprot):
8822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8824 
      return
8825 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8826 
    if self.name is not None:
1845 vikas 8827 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8828 
      oprot.writeString(self.name)
8829 
      oprot.writeFieldEnd()
3431 rajveer 8830 
    if self.addedOn is not None:
1859 vikas 8831 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8832 
      oprot.writeI64(self.addedOn)
8833 
      oprot.writeFieldEnd()
1845 vikas 8834 
    oprot.writeFieldStop()
8835 
    oprot.writeStructEnd()
8836 
 
3431 rajveer 8837 
  def validate(self):
8838 
    return
8839 
 
8840 
 
1845 vikas 8841 
  def __repr__(self):
8842 
    L = ['%s=%r' % (key, value)
8843 
      for key, value in self.__dict__.iteritems()]
8844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8845 
 
8846 
  def __eq__(self, other):
8847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8848 
 
8849 
  def __ne__(self, other):
8850 
    return not (self == other)
8851 
 
8852 
class createMasterAffiliate_result:
8853 
  """
8854 
  Attributes:
8855 
   - success
8856 
   - utx
8857 
  """
8858 
 
8859 
  thrift_spec = (
8860 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8861 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8862 
  )
8863 
 
8864 
  def __init__(self, success=None, utx=None,):
8865 
    self.success = success
8866 
    self.utx = utx
8867 
 
8868 
  def read(self, iprot):
8869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8871 
      return
8872 
    iprot.readStructBegin()
8873 
    while True:
8874 
      (fname, ftype, fid) = iprot.readFieldBegin()
8875 
      if ftype == TType.STOP:
8876 
        break
8877 
      if fid == 0:
8878 
        if ftype == TType.STRUCT:
8879 
          self.success = MasterAffiliate()
8880 
          self.success.read(iprot)
8881 
        else:
8882 
          iprot.skip(ftype)
8883 
      elif fid == 1:
8884 
        if ftype == TType.STRUCT:
1996 vikas 8885 
          self.utx = UserAffiliateException()
1845 vikas 8886 
          self.utx.read(iprot)
8887 
        else:
8888 
          iprot.skip(ftype)
8889 
      else:
8890 
        iprot.skip(ftype)
8891 
      iprot.readFieldEnd()
8892 
    iprot.readStructEnd()
8893 
 
8894 
  def write(self, oprot):
8895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8897 
      return
8898 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8899 
    if self.success is not None:
1845 vikas 8900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8901 
      self.success.write(oprot)
8902 
      oprot.writeFieldEnd()
3431 rajveer 8903 
    if self.utx is not None:
1845 vikas 8904 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8905 
      self.utx.write(oprot)
8906 
      oprot.writeFieldEnd()
8907 
    oprot.writeFieldStop()
8908 
    oprot.writeStructEnd()
8909 
 
3431 rajveer 8910 
  def validate(self):
8911 
    return
8912 
 
8913 
 
1845 vikas 8914 
  def __repr__(self):
8915 
    L = ['%s=%r' % (key, value)
8916 
      for key, value in self.__dict__.iteritems()]
8917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8918 
 
8919 
  def __eq__(self, other):
8920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8921 
 
8922 
  def __ne__(self, other):
8923 
    return not (self == other)
8924 
 
1899 vikas 8925 
class getAllMasterAffiliates_args:
8926 
 
8927 
  thrift_spec = (
8928 
  )
8929 
 
8930 
  def read(self, iprot):
8931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8933 
      return
8934 
    iprot.readStructBegin()
8935 
    while True:
8936 
      (fname, ftype, fid) = iprot.readFieldBegin()
8937 
      if ftype == TType.STOP:
8938 
        break
8939 
      else:
8940 
        iprot.skip(ftype)
8941 
      iprot.readFieldEnd()
8942 
    iprot.readStructEnd()
8943 
 
8944 
  def write(self, oprot):
8945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8947 
      return
8948 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8949 
    oprot.writeFieldStop()
8950 
    oprot.writeStructEnd()
8951 
 
3431 rajveer 8952 
  def validate(self):
8953 
    return
8954 
 
8955 
 
1899 vikas 8956 
  def __repr__(self):
8957 
    L = ['%s=%r' % (key, value)
8958 
      for key, value in self.__dict__.iteritems()]
8959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8960 
 
8961 
  def __eq__(self, other):
8962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8963 
 
8964 
  def __ne__(self, other):
8965 
    return not (self == other)
8966 
 
8967 
class getAllMasterAffiliates_result:
8968 
  """
8969 
  Attributes:
8970 
   - success
8971 
   - utx
8972 
  """
8973 
 
8974 
  thrift_spec = (
8975 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8976 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8977 
  )
8978 
 
8979 
  def __init__(self, success=None, utx=None,):
8980 
    self.success = success
8981 
    self.utx = utx
8982 
 
8983 
  def read(self, iprot):
8984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8986 
      return
8987 
    iprot.readStructBegin()
8988 
    while True:
8989 
      (fname, ftype, fid) = iprot.readFieldBegin()
8990 
      if ftype == TType.STOP:
8991 
        break
8992 
      if fid == 0:
8993 
        if ftype == TType.LIST:
8994 
          self.success = []
11592 amit.gupta 8995 
          (_etype121, _size118) = iprot.readListBegin()
8996 
          for _i122 in xrange(_size118):
8997 
            _elem123 = MasterAffiliate()
8998 
            _elem123.read(iprot)
8999 
            self.success.append(_elem123)
1899 vikas 9000 
          iprot.readListEnd()
9001 
        else:
9002 
          iprot.skip(ftype)
9003 
      elif fid == 1:
9004 
        if ftype == TType.STRUCT:
1996 vikas 9005 
          self.utx = UserAffiliateException()
1899 vikas 9006 
          self.utx.read(iprot)
9007 
        else:
9008 
          iprot.skip(ftype)
9009 
      else:
9010 
        iprot.skip(ftype)
9011 
      iprot.readFieldEnd()
9012 
    iprot.readStructEnd()
9013 
 
9014 
  def write(self, oprot):
9015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9017 
      return
9018 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 9019 
    if self.success is not None:
1899 vikas 9020 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9021 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9022 
      for iter124 in self.success:
9023 
        iter124.write(oprot)
1899 vikas 9024 
      oprot.writeListEnd()
9025 
      oprot.writeFieldEnd()
3431 rajveer 9026 
    if self.utx is not None:
1899 vikas 9027 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9028 
      self.utx.write(oprot)
9029 
      oprot.writeFieldEnd()
9030 
    oprot.writeFieldStop()
9031 
    oprot.writeStructEnd()
9032 
 
3431 rajveer 9033 
  def validate(self):
9034 
    return
9035 
 
9036 
 
1899 vikas 9037 
  def __repr__(self):
9038 
    L = ['%s=%r' % (key, value)
9039 
      for key, value in self.__dict__.iteritems()]
9040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9041 
 
9042 
  def __eq__(self, other):
9043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9044 
 
9045 
  def __ne__(self, other):
9046 
    return not (self == other)
9047 
 
1845 vikas 9048 
class getMasterAffiliateById_args:
9049 
  """
9050 
  Attributes:
9051 
   - id
9052 
  """
9053 
 
9054 
  thrift_spec = (
9055 
    None, # 0
9056 
    (1, TType.I64, 'id', None, None, ), # 1
9057 
  )
9058 
 
9059 
  def __init__(self, id=None,):
9060 
    self.id = id
9061 
 
9062 
  def read(self, iprot):
9063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9065 
      return
9066 
    iprot.readStructBegin()
9067 
    while True:
9068 
      (fname, ftype, fid) = iprot.readFieldBegin()
9069 
      if ftype == TType.STOP:
9070 
        break
9071 
      if fid == 1:
9072 
        if ftype == TType.I64:
9073 
          self.id = iprot.readI64();
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      else:
9077 
        iprot.skip(ftype)
9078 
      iprot.readFieldEnd()
9079 
    iprot.readStructEnd()
9080 
 
9081 
  def write(self, oprot):
9082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9084 
      return
9085 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 9086 
    if self.id is not None:
1845 vikas 9087 
      oprot.writeFieldBegin('id', TType.I64, 1)
9088 
      oprot.writeI64(self.id)
9089 
      oprot.writeFieldEnd()
9090 
    oprot.writeFieldStop()
9091 
    oprot.writeStructEnd()
9092 
 
3431 rajveer 9093 
  def validate(self):
9094 
    return
9095 
 
9096 
 
1845 vikas 9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
9108 
class getMasterAffiliateById_result:
9109 
  """
9110 
  Attributes:
9111 
   - success
9112 
   - utx
9113 
  """
9114 
 
9115 
  thrift_spec = (
9116 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9117 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9118 
  )
9119 
 
9120 
  def __init__(self, success=None, utx=None,):
9121 
    self.success = success
9122 
    self.utx = utx
9123 
 
9124 
  def read(self, iprot):
9125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9127 
      return
9128 
    iprot.readStructBegin()
9129 
    while True:
9130 
      (fname, ftype, fid) = iprot.readFieldBegin()
9131 
      if ftype == TType.STOP:
9132 
        break
9133 
      if fid == 0:
9134 
        if ftype == TType.STRUCT:
9135 
          self.success = MasterAffiliate()
9136 
          self.success.read(iprot)
9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      elif fid == 1:
9140 
        if ftype == TType.STRUCT:
1996 vikas 9141 
          self.utx = UserAffiliateException()
1845 vikas 9142 
          self.utx.read(iprot)
9143 
        else:
9144 
          iprot.skip(ftype)
9145 
      else:
9146 
        iprot.skip(ftype)
9147 
      iprot.readFieldEnd()
9148 
    iprot.readStructEnd()
9149 
 
9150 
  def write(self, oprot):
9151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9153 
      return
9154 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9155 
    if self.success is not None:
1845 vikas 9156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9157 
      self.success.write(oprot)
9158 
      oprot.writeFieldEnd()
3431 rajveer 9159 
    if self.utx is not None:
1845 vikas 9160 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9161 
      self.utx.write(oprot)
9162 
      oprot.writeFieldEnd()
9163 
    oprot.writeFieldStop()
9164 
    oprot.writeStructEnd()
9165 
 
3431 rajveer 9166 
  def validate(self):
9167 
    return
9168 
 
9169 
 
1845 vikas 9170 
  def __repr__(self):
9171 
    L = ['%s=%r' % (key, value)
9172 
      for key, value in self.__dict__.iteritems()]
9173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9174 
 
9175 
  def __eq__(self, other):
9176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9177 
 
9178 
  def __ne__(self, other):
9179 
    return not (self == other)
9180 
 
9181 
class getMasterAffiliateByName_args:
9182 
  """
9183 
  Attributes:
9184 
   - name
9185 
  """
9186 
 
9187 
  thrift_spec = (
9188 
    None, # 0
9189 
    (1, TType.STRING, 'name', None, None, ), # 1
9190 
  )
9191 
 
9192 
  def __init__(self, name=None,):
9193 
    self.name = name
9194 
 
9195 
  def read(self, iprot):
9196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9198 
      return
9199 
    iprot.readStructBegin()
9200 
    while True:
9201 
      (fname, ftype, fid) = iprot.readFieldBegin()
9202 
      if ftype == TType.STOP:
9203 
        break
9204 
      if fid == 1:
9205 
        if ftype == TType.STRING:
9206 
          self.name = iprot.readString();
9207 
        else:
9208 
          iprot.skip(ftype)
9209 
      else:
9210 
        iprot.skip(ftype)
9211 
      iprot.readFieldEnd()
9212 
    iprot.readStructEnd()
9213 
 
9214 
  def write(self, oprot):
9215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9217 
      return
9218 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9219 
    if self.name is not None:
1845 vikas 9220 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9221 
      oprot.writeString(self.name)
9222 
      oprot.writeFieldEnd()
9223 
    oprot.writeFieldStop()
9224 
    oprot.writeStructEnd()
9225 
 
3431 rajveer 9226 
  def validate(self):
9227 
    return
9228 
 
9229 
 
1845 vikas 9230 
  def __repr__(self):
9231 
    L = ['%s=%r' % (key, value)
9232 
      for key, value in self.__dict__.iteritems()]
9233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9234 
 
9235 
  def __eq__(self, other):
9236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9237 
 
9238 
  def __ne__(self, other):
9239 
    return not (self == other)
9240 
 
9241 
class getMasterAffiliateByName_result:
9242 
  """
9243 
  Attributes:
9244 
   - success
9245 
   - utx
9246 
  """
9247 
 
9248 
  thrift_spec = (
9249 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9250 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9251 
  )
9252 
 
9253 
  def __init__(self, success=None, utx=None,):
9254 
    self.success = success
9255 
    self.utx = utx
9256 
 
9257 
  def read(self, iprot):
9258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9260 
      return
9261 
    iprot.readStructBegin()
9262 
    while True:
9263 
      (fname, ftype, fid) = iprot.readFieldBegin()
9264 
      if ftype == TType.STOP:
9265 
        break
9266 
      if fid == 0:
9267 
        if ftype == TType.STRUCT:
9268 
          self.success = MasterAffiliate()
9269 
          self.success.read(iprot)
9270 
        else:
9271 
          iprot.skip(ftype)
9272 
      elif fid == 1:
9273 
        if ftype == TType.STRUCT:
1996 vikas 9274 
          self.utx = UserAffiliateException()
1845 vikas 9275 
          self.utx.read(iprot)
9276 
        else:
9277 
          iprot.skip(ftype)
9278 
      else:
9279 
        iprot.skip(ftype)
9280 
      iprot.readFieldEnd()
9281 
    iprot.readStructEnd()
9282 
 
9283 
  def write(self, oprot):
9284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9286 
      return
9287 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9288 
    if self.success is not None:
1845 vikas 9289 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9290 
      self.success.write(oprot)
9291 
      oprot.writeFieldEnd()
3431 rajveer 9292 
    if self.utx is not None:
1845 vikas 9293 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9294 
      self.utx.write(oprot)
9295 
      oprot.writeFieldEnd()
9296 
    oprot.writeFieldStop()
9297 
    oprot.writeStructEnd()
9298 
 
3431 rajveer 9299 
  def validate(self):
9300 
    return
9301 
 
9302 
 
1845 vikas 9303 
  def __repr__(self):
9304 
    L = ['%s=%r' % (key, value)
9305 
      for key, value in self.__dict__.iteritems()]
9306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9307 
 
9308 
  def __eq__(self, other):
9309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9310 
 
9311 
  def __ne__(self, other):
9312 
    return not (self == other)
9313 
 
9314 
class createAffiliate_args:
9315 
  """
9316 
  Attributes:
9317 
   - name
9318 
   - url
9319 
   - masterAffiliateId
1859 vikas 9320 
   - addedOn
1845 vikas 9321 
  """
9322 
 
9323 
  thrift_spec = (
9324 
    None, # 0
9325 
    (1, TType.STRING, 'name', None, None, ), # 1
9326 
    (2, TType.STRING, 'url', None, None, ), # 2
9327 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9328 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9329 
  )
9330 
 
1859 vikas 9331 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9332 
    self.name = name
9333 
    self.url = url
9334 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9335 
    self.addedOn = addedOn
1845 vikas 9336 
 
9337 
  def read(self, iprot):
9338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9340 
      return
9341 
    iprot.readStructBegin()
9342 
    while True:
9343 
      (fname, ftype, fid) = iprot.readFieldBegin()
9344 
      if ftype == TType.STOP:
9345 
        break
9346 
      if fid == 1:
9347 
        if ftype == TType.STRING:
9348 
          self.name = iprot.readString();
9349 
        else:
9350 
          iprot.skip(ftype)
9351 
      elif fid == 2:
9352 
        if ftype == TType.STRING:
9353 
          self.url = iprot.readString();
9354 
        else:
9355 
          iprot.skip(ftype)
9356 
      elif fid == 3:
9357 
        if ftype == TType.I64:
9358 
          self.masterAffiliateId = iprot.readI64();
9359 
        else:
9360 
          iprot.skip(ftype)
1859 vikas 9361 
      elif fid == 4:
9362 
        if ftype == TType.I64:
9363 
          self.addedOn = iprot.readI64();
9364 
        else:
9365 
          iprot.skip(ftype)
1845 vikas 9366 
      else:
9367 
        iprot.skip(ftype)
9368 
      iprot.readFieldEnd()
9369 
    iprot.readStructEnd()
9370 
 
9371 
  def write(self, oprot):
9372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9374 
      return
9375 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9376 
    if self.name is not None:
1845 vikas 9377 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9378 
      oprot.writeString(self.name)
9379 
      oprot.writeFieldEnd()
3431 rajveer 9380 
    if self.url is not None:
1845 vikas 9381 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9382 
      oprot.writeString(self.url)
9383 
      oprot.writeFieldEnd()
3431 rajveer 9384 
    if self.masterAffiliateId is not None:
1845 vikas 9385 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9386 
      oprot.writeI64(self.masterAffiliateId)
9387 
      oprot.writeFieldEnd()
3431 rajveer 9388 
    if self.addedOn is not None:
1859 vikas 9389 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9390 
      oprot.writeI64(self.addedOn)
9391 
      oprot.writeFieldEnd()
1845 vikas 9392 
    oprot.writeFieldStop()
9393 
    oprot.writeStructEnd()
9394 
 
3431 rajveer 9395 
  def validate(self):
9396 
    return
9397 
 
9398 
 
1845 vikas 9399 
  def __repr__(self):
9400 
    L = ['%s=%r' % (key, value)
9401 
      for key, value in self.__dict__.iteritems()]
9402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9403 
 
9404 
  def __eq__(self, other):
9405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9406 
 
9407 
  def __ne__(self, other):
9408 
    return not (self == other)
9409 
 
9410 
class createAffiliate_result:
9411 
  """
9412 
  Attributes:
9413 
   - success
9414 
   - utx
9415 
  """
9416 
 
9417 
  thrift_spec = (
9418 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9419 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9420 
  )
9421 
 
9422 
  def __init__(self, success=None, utx=None,):
9423 
    self.success = success
9424 
    self.utx = utx
9425 
 
9426 
  def read(self, iprot):
9427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9429 
      return
9430 
    iprot.readStructBegin()
9431 
    while True:
9432 
      (fname, ftype, fid) = iprot.readFieldBegin()
9433 
      if ftype == TType.STOP:
9434 
        break
9435 
      if fid == 0:
9436 
        if ftype == TType.STRUCT:
9437 
          self.success = Affiliate()
9438 
          self.success.read(iprot)
9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      elif fid == 1:
9442 
        if ftype == TType.STRUCT:
1996 vikas 9443 
          self.utx = UserAffiliateException()
1845 vikas 9444 
          self.utx.read(iprot)
9445 
        else:
9446 
          iprot.skip(ftype)
9447 
      else:
9448 
        iprot.skip(ftype)
9449 
      iprot.readFieldEnd()
9450 
    iprot.readStructEnd()
9451 
 
9452 
  def write(self, oprot):
9453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9455 
      return
9456 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9457 
    if self.success is not None:
1845 vikas 9458 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9459 
      self.success.write(oprot)
9460 
      oprot.writeFieldEnd()
3431 rajveer 9461 
    if self.utx is not None:
1845 vikas 9462 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9463 
      self.utx.write(oprot)
9464 
      oprot.writeFieldEnd()
9465 
    oprot.writeFieldStop()
9466 
    oprot.writeStructEnd()
9467 
 
3431 rajveer 9468 
  def validate(self):
9469 
    return
9470 
 
9471 
 
1845 vikas 9472 
  def __repr__(self):
9473 
    L = ['%s=%r' % (key, value)
9474 
      for key, value in self.__dict__.iteritems()]
9475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9476 
 
9477 
  def __eq__(self, other):
9478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9479 
 
9480 
  def __ne__(self, other):
9481 
    return not (self == other)
9482 
 
9483 
class getAffiliateById_args:
9484 
  """
9485 
  Attributes:
9486 
   - id
9487 
  """
9488 
 
9489 
  thrift_spec = (
9490 
    None, # 0
9491 
    (1, TType.I64, 'id', None, None, ), # 1
9492 
  )
9493 
 
9494 
  def __init__(self, id=None,):
9495 
    self.id = id
9496 
 
9497 
  def read(self, iprot):
9498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9500 
      return
9501 
    iprot.readStructBegin()
9502 
    while True:
9503 
      (fname, ftype, fid) = iprot.readFieldBegin()
9504 
      if ftype == TType.STOP:
9505 
        break
9506 
      if fid == 1:
9507 
        if ftype == TType.I64:
9508 
          self.id = iprot.readI64();
9509 
        else:
9510 
          iprot.skip(ftype)
9511 
      else:
9512 
        iprot.skip(ftype)
9513 
      iprot.readFieldEnd()
9514 
    iprot.readStructEnd()
9515 
 
9516 
  def write(self, oprot):
9517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9519 
      return
9520 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9521 
    if self.id is not None:
1845 vikas 9522 
      oprot.writeFieldBegin('id', TType.I64, 1)
9523 
      oprot.writeI64(self.id)
9524 
      oprot.writeFieldEnd()
9525 
    oprot.writeFieldStop()
9526 
    oprot.writeStructEnd()
9527 
 
3431 rajveer 9528 
  def validate(self):
9529 
    return
9530 
 
9531 
 
1845 vikas 9532 
  def __repr__(self):
9533 
    L = ['%s=%r' % (key, value)
9534 
      for key, value in self.__dict__.iteritems()]
9535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9536 
 
9537 
  def __eq__(self, other):
9538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9539 
 
9540 
  def __ne__(self, other):
9541 
    return not (self == other)
9542 
 
9543 
class getAffiliateById_result:
9544 
  """
9545 
  Attributes:
9546 
   - success
9547 
   - utx
9548 
  """
9549 
 
9550 
  thrift_spec = (
9551 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9552 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9553 
  )
9554 
 
9555 
  def __init__(self, success=None, utx=None,):
9556 
    self.success = success
9557 
    self.utx = utx
9558 
 
9559 
  def read(self, iprot):
9560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9562 
      return
9563 
    iprot.readStructBegin()
9564 
    while True:
9565 
      (fname, ftype, fid) = iprot.readFieldBegin()
9566 
      if ftype == TType.STOP:
9567 
        break
9568 
      if fid == 0:
9569 
        if ftype == TType.STRUCT:
9570 
          self.success = Affiliate()
9571 
          self.success.read(iprot)
9572 
        else:
9573 
          iprot.skip(ftype)
9574 
      elif fid == 1:
9575 
        if ftype == TType.STRUCT:
1996 vikas 9576 
          self.utx = UserAffiliateException()
1845 vikas 9577 
          self.utx.read(iprot)
9578 
        else:
9579 
          iprot.skip(ftype)
9580 
      else:
9581 
        iprot.skip(ftype)
9582 
      iprot.readFieldEnd()
9583 
    iprot.readStructEnd()
9584 
 
9585 
  def write(self, oprot):
9586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9588 
      return
9589 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9590 
    if self.success is not None:
1845 vikas 9591 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9592 
      self.success.write(oprot)
9593 
      oprot.writeFieldEnd()
3431 rajveer 9594 
    if self.utx is not None:
1845 vikas 9595 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9596 
      self.utx.write(oprot)
9597 
      oprot.writeFieldEnd()
9598 
    oprot.writeFieldStop()
9599 
    oprot.writeStructEnd()
9600 
 
3431 rajveer 9601 
  def validate(self):
9602 
    return
9603 
 
9604 
 
1845 vikas 9605 
  def __repr__(self):
9606 
    L = ['%s=%r' % (key, value)
9607 
      for key, value in self.__dict__.iteritems()]
9608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9609 
 
9610 
  def __eq__(self, other):
9611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9612 
 
9613 
  def __ne__(self, other):
9614 
    return not (self == other)
9615 
 
9616 
class getAffiliateByName_args:
9617 
  """
9618 
  Attributes:
9619 
   - name
9620 
  """
9621 
 
9622 
  thrift_spec = (
9623 
    None, # 0
9624 
    (1, TType.STRING, 'name', None, None, ), # 1
9625 
  )
9626 
 
9627 
  def __init__(self, name=None,):
9628 
    self.name = name
9629 
 
9630 
  def read(self, iprot):
9631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9633 
      return
9634 
    iprot.readStructBegin()
9635 
    while True:
9636 
      (fname, ftype, fid) = iprot.readFieldBegin()
9637 
      if ftype == TType.STOP:
9638 
        break
9639 
      if fid == 1:
9640 
        if ftype == TType.STRING:
9641 
          self.name = iprot.readString();
9642 
        else:
9643 
          iprot.skip(ftype)
9644 
      else:
9645 
        iprot.skip(ftype)
9646 
      iprot.readFieldEnd()
9647 
    iprot.readStructEnd()
9648 
 
9649 
  def write(self, oprot):
9650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9652 
      return
9653 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9654 
    if self.name is not None:
1845 vikas 9655 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9656 
      oprot.writeString(self.name)
9657 
      oprot.writeFieldEnd()
9658 
    oprot.writeFieldStop()
9659 
    oprot.writeStructEnd()
9660 
 
3431 rajveer 9661 
  def validate(self):
9662 
    return
9663 
 
9664 
 
1845 vikas 9665 
  def __repr__(self):
9666 
    L = ['%s=%r' % (key, value)
9667 
      for key, value in self.__dict__.iteritems()]
9668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9669 
 
9670 
  def __eq__(self, other):
9671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9672 
 
9673 
  def __ne__(self, other):
9674 
    return not (self == other)
9675 
 
9676 
class getAffiliateByName_result:
9677 
  """
9678 
  Attributes:
9679 
   - success
9680 
   - utx
9681 
  """
9682 
 
9683 
  thrift_spec = (
9684 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9685 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9686 
  )
9687 
 
9688 
  def __init__(self, success=None, utx=None,):
9689 
    self.success = success
9690 
    self.utx = utx
9691 
 
9692 
  def read(self, iprot):
9693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9695 
      return
9696 
    iprot.readStructBegin()
9697 
    while True:
9698 
      (fname, ftype, fid) = iprot.readFieldBegin()
9699 
      if ftype == TType.STOP:
9700 
        break
9701 
      if fid == 0:
9702 
        if ftype == TType.STRUCT:
9703 
          self.success = Affiliate()
9704 
          self.success.read(iprot)
9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      elif fid == 1:
9708 
        if ftype == TType.STRUCT:
1996 vikas 9709 
          self.utx = UserAffiliateException()
1845 vikas 9710 
          self.utx.read(iprot)
9711 
        else:
9712 
          iprot.skip(ftype)
9713 
      else:
9714 
        iprot.skip(ftype)
9715 
      iprot.readFieldEnd()
9716 
    iprot.readStructEnd()
9717 
 
9718 
  def write(self, oprot):
9719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9721 
      return
9722 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9723 
    if self.success is not None:
1845 vikas 9724 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9725 
      self.success.write(oprot)
9726 
      oprot.writeFieldEnd()
3431 rajveer 9727 
    if self.utx is not None:
1845 vikas 9728 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9729 
      self.utx.write(oprot)
9730 
      oprot.writeFieldEnd()
9731 
    oprot.writeFieldStop()
9732 
    oprot.writeStructEnd()
9733 
 
3431 rajveer 9734 
  def validate(self):
9735 
    return
9736 
 
9737 
 
1845 vikas 9738 
  def __repr__(self):
9739 
    L = ['%s=%r' % (key, value)
9740 
      for key, value in self.__dict__.iteritems()]
9741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9742 
 
9743 
  def __eq__(self, other):
9744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9745 
 
9746 
  def __ne__(self, other):
9747 
    return not (self == other)
9748 
 
1996 vikas 9749 
class getTrackerById_args:
1845 vikas 9750 
  """
9751 
  Attributes:
9752 
   - id
9753 
  """
9754 
 
9755 
  thrift_spec = (
9756 
    None, # 0
9757 
    (1, TType.I64, 'id', None, None, ), # 1
9758 
  )
9759 
 
9760 
  def __init__(self, id=None,):
9761 
    self.id = id
9762 
 
9763 
  def read(self, iprot):
9764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9766 
      return
9767 
    iprot.readStructBegin()
9768 
    while True:
9769 
      (fname, ftype, fid) = iprot.readFieldBegin()
9770 
      if ftype == TType.STOP:
9771 
        break
9772 
      if fid == 1:
9773 
        if ftype == TType.I64:
9774 
          self.id = iprot.readI64();
9775 
        else:
9776 
          iprot.skip(ftype)
9777 
      else:
9778 
        iprot.skip(ftype)
9779 
      iprot.readFieldEnd()
9780 
    iprot.readStructEnd()
9781 
 
9782 
  def write(self, oprot):
9783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9785 
      return
1996 vikas 9786 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9787 
    if self.id is not None:
1845 vikas 9788 
      oprot.writeFieldBegin('id', TType.I64, 1)
9789 
      oprot.writeI64(self.id)
9790 
      oprot.writeFieldEnd()
9791 
    oprot.writeFieldStop()
9792 
    oprot.writeStructEnd()
9793 
 
3431 rajveer 9794 
  def validate(self):
9795 
    return
9796 
 
9797 
 
1845 vikas 9798 
  def __repr__(self):
9799 
    L = ['%s=%r' % (key, value)
9800 
      for key, value in self.__dict__.iteritems()]
9801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9802 
 
9803 
  def __eq__(self, other):
9804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9805 
 
9806 
  def __ne__(self, other):
9807 
    return not (self == other)
9808 
 
9809 
class getTrackerById_result:
9810 
  """
9811 
  Attributes:
9812 
   - success
9813 
   - utx
9814 
  """
9815 
 
9816 
  thrift_spec = (
9817 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9818 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9819 
  )
9820 
 
9821 
  def __init__(self, success=None, utx=None,):
9822 
    self.success = success
9823 
    self.utx = utx
9824 
 
9825 
  def read(self, iprot):
9826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9828 
      return
9829 
    iprot.readStructBegin()
9830 
    while True:
9831 
      (fname, ftype, fid) = iprot.readFieldBegin()
9832 
      if ftype == TType.STOP:
9833 
        break
9834 
      if fid == 0:
9835 
        if ftype == TType.STRUCT:
9836 
          self.success = Tracker()
9837 
          self.success.read(iprot)
9838 
        else:
9839 
          iprot.skip(ftype)
9840 
      elif fid == 1:
9841 
        if ftype == TType.STRUCT:
1996 vikas 9842 
          self.utx = UserAffiliateException()
1845 vikas 9843 
          self.utx.read(iprot)
9844 
        else:
9845 
          iprot.skip(ftype)
9846 
      else:
9847 
        iprot.skip(ftype)
9848 
      iprot.readFieldEnd()
9849 
    iprot.readStructEnd()
9850 
 
9851 
  def write(self, oprot):
9852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9854 
      return
9855 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9856 
    if self.success is not None:
1845 vikas 9857 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9858 
      self.success.write(oprot)
9859 
      oprot.writeFieldEnd()
3431 rajveer 9860 
    if self.utx is not None:
1845 vikas 9861 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9862 
      self.utx.write(oprot)
9863 
      oprot.writeFieldEnd()
9864 
    oprot.writeFieldStop()
9865 
    oprot.writeStructEnd()
9866 
 
3431 rajveer 9867 
  def validate(self):
9868 
    return
9869 
 
9870 
 
1845 vikas 9871 
  def __repr__(self):
9872 
    L = ['%s=%r' % (key, value)
9873 
      for key, value in self.__dict__.iteritems()]
9874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9875 
 
9876 
  def __eq__(self, other):
9877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9878 
 
9879 
  def __ne__(self, other):
9880 
    return not (self == other)
9881 
 
1996 vikas 9882 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9883 
  """
9884 
  Attributes:
1996 vikas 9885 
   - id
1845 vikas 9886 
  """
9887 
 
9888 
  thrift_spec = (
9889 
    None, # 0
1996 vikas 9890 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9891 
  )
9892 
 
1996 vikas 9893 
  def __init__(self, id=None,):
9894 
    self.id = id
1845 vikas 9895 
 
9896 
  def read(self, iprot):
9897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9899 
      return
9900 
    iprot.readStructBegin()
9901 
    while True:
9902 
      (fname, ftype, fid) = iprot.readFieldBegin()
9903 
      if ftype == TType.STOP:
9904 
        break
9905 
      if fid == 1:
9906 
        if ftype == TType.I64:
1996 vikas 9907 
          self.id = iprot.readI64();
1845 vikas 9908 
        else:
9909 
          iprot.skip(ftype)
9910 
      else:
9911 
        iprot.skip(ftype)
9912 
      iprot.readFieldEnd()
9913 
    iprot.readStructEnd()
9914 
 
9915 
  def write(self, oprot):
9916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9918 
      return
1996 vikas 9919 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9920 
    if self.id is not None:
1996 vikas 9921 
      oprot.writeFieldBegin('id', TType.I64, 1)
9922 
      oprot.writeI64(self.id)
1845 vikas 9923 
      oprot.writeFieldEnd()
9924 
    oprot.writeFieldStop()
9925 
    oprot.writeStructEnd()
9926 
 
3431 rajveer 9927 
  def validate(self):
9928 
    return
9929 
 
9930 
 
1845 vikas 9931 
  def __repr__(self):
9932 
    L = ['%s=%r' % (key, value)
9933 
      for key, value in self.__dict__.iteritems()]
9934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9935 
 
9936 
  def __eq__(self, other):
9937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9938 
 
9939 
  def __ne__(self, other):
9940 
    return not (self == other)
9941 
 
1996 vikas 9942 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9943 
  """
9944 
  Attributes:
9945 
   - success
9946 
   - utx
9947 
  """
9948 
 
9949 
  thrift_spec = (
1996 vikas 9950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9951 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9952 
  )
9953 
 
9954 
  def __init__(self, success=None, utx=None,):
9955 
    self.success = success
9956 
    self.utx = utx
9957 
 
9958 
  def read(self, iprot):
9959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9961 
      return
9962 
    iprot.readStructBegin()
9963 
    while True:
9964 
      (fname, ftype, fid) = iprot.readFieldBegin()
9965 
      if ftype == TType.STOP:
9966 
        break
9967 
      if fid == 0:
9968 
        if ftype == TType.LIST:
9969 
          self.success = []
11592 amit.gupta 9970 
          (_etype128, _size125) = iprot.readListBegin()
9971 
          for _i129 in xrange(_size125):
9972 
            _elem130 = Affiliate()
9973 
            _elem130.read(iprot)
9974 
            self.success.append(_elem130)
1845 vikas 9975 
          iprot.readListEnd()
9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      elif fid == 1:
9979 
        if ftype == TType.STRUCT:
1996 vikas 9980 
          self.utx = UserAffiliateException()
1845 vikas 9981 
          self.utx.read(iprot)
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      else:
9985 
        iprot.skip(ftype)
9986 
      iprot.readFieldEnd()
9987 
    iprot.readStructEnd()
9988 
 
9989 
  def write(self, oprot):
9990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9992 
      return
1996 vikas 9993 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9994 
    if self.success is not None:
1845 vikas 9995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9996 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9997 
      for iter131 in self.success:
9998 
        iter131.write(oprot)
1845 vikas 9999 
      oprot.writeListEnd()
10000 
      oprot.writeFieldEnd()
3431 rajveer 10001 
    if self.utx is not None:
1845 vikas 10002 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10003 
      self.utx.write(oprot)
10004 
      oprot.writeFieldEnd()
10005 
    oprot.writeFieldStop()
10006 
    oprot.writeStructEnd()
10007 
 
3431 rajveer 10008 
  def validate(self):
10009 
    return
10010 
 
10011 
 
1845 vikas 10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
10023 
class addTrackLog_args:
10024 
  """
10025 
  Attributes:
1996 vikas 10026 
   - affiliateId
1845 vikas 10027 
   - userId
10028 
   - event
10029 
   - url
10030 
   - data
1859 vikas 10031 
   - addedOn
1845 vikas 10032 
  """
10033 
 
10034 
  thrift_spec = (
10035 
    None, # 0
1996 vikas 10036 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 10037 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 10038 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 10039 
    (4, TType.STRING, 'url', None, None, ), # 4
10040 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 10041 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 10042 
  )
10043 
 
1996 vikas 10044 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
10045 
    self.affiliateId = affiliateId
1845 vikas 10046 
    self.userId = userId
10047 
    self.event = event
10048 
    self.url = url
10049 
    self.data = data
1859 vikas 10050 
    self.addedOn = addedOn
1845 vikas 10051 
 
10052 
  def read(self, iprot):
10053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10055 
      return
10056 
    iprot.readStructBegin()
10057 
    while True:
10058 
      (fname, ftype, fid) = iprot.readFieldBegin()
10059 
      if ftype == TType.STOP:
10060 
        break
10061 
      if fid == 1:
10062 
        if ftype == TType.I64:
1996 vikas 10063 
          self.affiliateId = iprot.readI64();
1845 vikas 10064 
        else:
10065 
          iprot.skip(ftype)
10066 
      elif fid == 2:
10067 
        if ftype == TType.I64:
10068 
          self.userId = iprot.readI64();
10069 
        else:
10070 
          iprot.skip(ftype)
10071 
      elif fid == 3:
3378 vikas 10072 
        if ftype == TType.I32:
10073 
          self.event = iprot.readI32();
1845 vikas 10074 
        else:
10075 
          iprot.skip(ftype)
10076 
      elif fid == 4:
10077 
        if ftype == TType.STRING:
10078 
          self.url = iprot.readString();
10079 
        else:
10080 
          iprot.skip(ftype)
10081 
      elif fid == 5:
10082 
        if ftype == TType.STRING:
10083 
          self.data = iprot.readString();
10084 
        else:
10085 
          iprot.skip(ftype)
1859 vikas 10086 
      elif fid == 6:
10087 
        if ftype == TType.I64:
10088 
          self.addedOn = iprot.readI64();
10089 
        else:
10090 
          iprot.skip(ftype)
1845 vikas 10091 
      else:
10092 
        iprot.skip(ftype)
10093 
      iprot.readFieldEnd()
10094 
    iprot.readStructEnd()
10095 
 
10096 
  def write(self, oprot):
10097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10099 
      return
10100 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10101 
    if self.affiliateId is not None:
1996 vikas 10102 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10103 
      oprot.writeI64(self.affiliateId)
1845 vikas 10104 
      oprot.writeFieldEnd()
3431 rajveer 10105 
    if self.userId is not None:
1845 vikas 10106 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10107 
      oprot.writeI64(self.userId)
10108 
      oprot.writeFieldEnd()
3431 rajveer 10109 
    if self.event is not None:
3378 vikas 10110 
      oprot.writeFieldBegin('event', TType.I32, 3)
10111 
      oprot.writeI32(self.event)
1845 vikas 10112 
      oprot.writeFieldEnd()
3431 rajveer 10113 
    if self.url is not None:
1845 vikas 10114 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10115 
      oprot.writeString(self.url)
10116 
      oprot.writeFieldEnd()
3431 rajveer 10117 
    if self.data is not None:
1845 vikas 10118 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10119 
      oprot.writeString(self.data)
10120 
      oprot.writeFieldEnd()
3431 rajveer 10121 
    if self.addedOn is not None:
1859 vikas 10122 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10123 
      oprot.writeI64(self.addedOn)
10124 
      oprot.writeFieldEnd()
1845 vikas 10125 
    oprot.writeFieldStop()
10126 
    oprot.writeStructEnd()
10127 
 
3431 rajveer 10128 
  def validate(self):
10129 
    return
10130 
 
10131 
 
1845 vikas 10132 
  def __repr__(self):
10133 
    L = ['%s=%r' % (key, value)
10134 
      for key, value in self.__dict__.iteritems()]
10135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10136 
 
10137 
  def __eq__(self, other):
10138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10139 
 
10140 
  def __ne__(self, other):
10141 
    return not (self == other)
10142 
 
10143 
class addTrackLog_result:
10144 
  """
10145 
  Attributes:
10146 
   - success
10147 
   - utx
10148 
  """
10149 
 
10150 
  thrift_spec = (
10151 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10152 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10153 
  )
10154 
 
10155 
  def __init__(self, success=None, utx=None,):
10156 
    self.success = success
10157 
    self.utx = utx
10158 
 
10159 
  def read(self, iprot):
10160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10162 
      return
10163 
    iprot.readStructBegin()
10164 
    while True:
10165 
      (fname, ftype, fid) = iprot.readFieldBegin()
10166 
      if ftype == TType.STOP:
10167 
        break
10168 
      if fid == 0:
10169 
        if ftype == TType.I64:
10170 
          self.success = iprot.readI64();
10171 
        else:
10172 
          iprot.skip(ftype)
10173 
      elif fid == 1:
10174 
        if ftype == TType.STRUCT:
1996 vikas 10175 
          self.utx = UserAffiliateException()
1845 vikas 10176 
          self.utx.read(iprot)
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      else:
10180 
        iprot.skip(ftype)
10181 
      iprot.readFieldEnd()
10182 
    iprot.readStructEnd()
10183 
 
10184 
  def write(self, oprot):
10185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10187 
      return
10188 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10189 
    if self.success is not None:
1845 vikas 10190 
      oprot.writeFieldBegin('success', TType.I64, 0)
10191 
      oprot.writeI64(self.success)
10192 
      oprot.writeFieldEnd()
3431 rajveer 10193 
    if self.utx is not None:
1845 vikas 10194 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10195 
      self.utx.write(oprot)
10196 
      oprot.writeFieldEnd()
10197 
    oprot.writeFieldStop()
10198 
    oprot.writeStructEnd()
10199 
 
3431 rajveer 10200 
  def validate(self):
10201 
    return
10202 
 
10203 
 
1845 vikas 10204 
  def __repr__(self):
10205 
    L = ['%s=%r' % (key, value)
10206 
      for key, value in self.__dict__.iteritems()]
10207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10208 
 
10209 
  def __eq__(self, other):
10210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10211 
 
10212 
  def __ne__(self, other):
10213 
    return not (self == other)
10214 
 
10215 
class getTrackLogById_args:
10216 
  """
10217 
  Attributes:
10218 
   - id
10219 
  """
10220 
 
10221 
  thrift_spec = (
10222 
    None, # 0
10223 
    (1, TType.I64, 'id', None, None, ), # 1
10224 
  )
10225 
 
10226 
  def __init__(self, id=None,):
10227 
    self.id = id
10228 
 
10229 
  def read(self, iprot):
10230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10232 
      return
10233 
    iprot.readStructBegin()
10234 
    while True:
10235 
      (fname, ftype, fid) = iprot.readFieldBegin()
10236 
      if ftype == TType.STOP:
10237 
        break
10238 
      if fid == 1:
10239 
        if ftype == TType.I64:
10240 
          self.id = iprot.readI64();
10241 
        else:
10242 
          iprot.skip(ftype)
10243 
      else:
10244 
        iprot.skip(ftype)
10245 
      iprot.readFieldEnd()
10246 
    iprot.readStructEnd()
10247 
 
10248 
  def write(self, oprot):
10249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10251 
      return
10252 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10253 
    if self.id is not None:
1845 vikas 10254 
      oprot.writeFieldBegin('id', TType.I64, 1)
10255 
      oprot.writeI64(self.id)
10256 
      oprot.writeFieldEnd()
10257 
    oprot.writeFieldStop()
10258 
    oprot.writeStructEnd()
10259 
 
3431 rajveer 10260 
  def validate(self):
10261 
    return
10262 
 
10263 
 
1845 vikas 10264 
  def __repr__(self):
10265 
    L = ['%s=%r' % (key, value)
10266 
      for key, value in self.__dict__.iteritems()]
10267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10268 
 
10269 
  def __eq__(self, other):
10270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10271 
 
10272 
  def __ne__(self, other):
10273 
    return not (self == other)
10274 
 
10275 
class getTrackLogById_result:
10276 
  """
10277 
  Attributes:
10278 
   - success
10279 
   - utx
10280 
  """
10281 
 
10282 
  thrift_spec = (
10283 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10284 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10285 
  )
10286 
 
10287 
  def __init__(self, success=None, utx=None,):
10288 
    self.success = success
10289 
    self.utx = utx
10290 
 
10291 
  def read(self, iprot):
10292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10294 
      return
10295 
    iprot.readStructBegin()
10296 
    while True:
10297 
      (fname, ftype, fid) = iprot.readFieldBegin()
10298 
      if ftype == TType.STOP:
10299 
        break
10300 
      if fid == 0:
10301 
        if ftype == TType.STRUCT:
10302 
          self.success = TrackLog()
10303 
          self.success.read(iprot)
10304 
        else:
10305 
          iprot.skip(ftype)
10306 
      elif fid == 1:
10307 
        if ftype == TType.STRUCT:
1996 vikas 10308 
          self.utx = UserAffiliateException()
1845 vikas 10309 
          self.utx.read(iprot)
10310 
        else:
10311 
          iprot.skip(ftype)
10312 
      else:
10313 
        iprot.skip(ftype)
10314 
      iprot.readFieldEnd()
10315 
    iprot.readStructEnd()
10316 
 
10317 
  def write(self, oprot):
10318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10320 
      return
10321 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10322 
    if self.success is not None:
1845 vikas 10323 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10324 
      self.success.write(oprot)
10325 
      oprot.writeFieldEnd()
3431 rajveer 10326 
    if self.utx is not None:
1845 vikas 10327 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10328 
      self.utx.write(oprot)
10329 
      oprot.writeFieldEnd()
10330 
    oprot.writeFieldStop()
10331 
    oprot.writeStructEnd()
10332 
 
3431 rajveer 10333 
  def validate(self):
10334 
    return
10335 
 
10336 
 
1845 vikas 10337 
  def __repr__(self):
10338 
    L = ['%s=%r' % (key, value)
10339 
      for key, value in self.__dict__.iteritems()]
10340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10341 
 
10342 
  def __eq__(self, other):
10343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10344 
 
10345 
  def __ne__(self, other):
10346 
    return not (self == other)
10347 
 
1996 vikas 10348 
class getTrackLogsByAffiliate_args:
1845 vikas 10349 
  """
10350 
  Attributes:
1996 vikas 10351 
   - affiliateId
3293 vikas 10352 
   - startDate
10353 
   - endDate
1845 vikas 10354 
  """
10355 
 
10356 
  thrift_spec = (
10357 
    None, # 0
1996 vikas 10358 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10359 
    (2, TType.I64, 'startDate', None, None, ), # 2
10360 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10361 
  )
10362 
 
3293 vikas 10363 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10364 
    self.affiliateId = affiliateId
3293 vikas 10365 
    self.startDate = startDate
10366 
    self.endDate = endDate
1845 vikas 10367 
 
10368 
  def read(self, iprot):
10369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10371 
      return
10372 
    iprot.readStructBegin()
10373 
    while True:
10374 
      (fname, ftype, fid) = iprot.readFieldBegin()
10375 
      if ftype == TType.STOP:
10376 
        break
10377 
      if fid == 1:
10378 
        if ftype == TType.I64:
1996 vikas 10379 
          self.affiliateId = iprot.readI64();
1845 vikas 10380 
        else:
10381 
          iprot.skip(ftype)
3293 vikas 10382 
      elif fid == 2:
10383 
        if ftype == TType.I64:
10384 
          self.startDate = iprot.readI64();
10385 
        else:
10386 
          iprot.skip(ftype)
10387 
      elif fid == 3:
10388 
        if ftype == TType.I64:
10389 
          self.endDate = iprot.readI64();
10390 
        else:
10391 
          iprot.skip(ftype)
1845 vikas 10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
1996 vikas 10401 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10402 
    if self.affiliateId is not None:
1996 vikas 10403 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10404 
      oprot.writeI64(self.affiliateId)
1845 vikas 10405 
      oprot.writeFieldEnd()
3431 rajveer 10406 
    if self.startDate is not None:
3293 vikas 10407 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10408 
      oprot.writeI64(self.startDate)
10409 
      oprot.writeFieldEnd()
3431 rajveer 10410 
    if self.endDate is not None:
3293 vikas 10411 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10412 
      oprot.writeI64(self.endDate)
10413 
      oprot.writeFieldEnd()
1845 vikas 10414 
    oprot.writeFieldStop()
10415 
    oprot.writeStructEnd()
10416 
 
3431 rajveer 10417 
  def validate(self):
10418 
    return
10419 
 
10420 
 
1845 vikas 10421 
  def __repr__(self):
10422 
    L = ['%s=%r' % (key, value)
10423 
      for key, value in self.__dict__.iteritems()]
10424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10425 
 
10426 
  def __eq__(self, other):
10427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10428 
 
10429 
  def __ne__(self, other):
10430 
    return not (self == other)
10431 
 
1996 vikas 10432 
class getTrackLogsByAffiliate_result:
1845 vikas 10433 
  """
10434 
  Attributes:
10435 
   - success
10436 
   - utx
10437 
  """
10438 
 
10439 
  thrift_spec = (
10440 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10441 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10442 
  )
10443 
 
10444 
  def __init__(self, success=None, utx=None,):
10445 
    self.success = success
10446 
    self.utx = utx
10447 
 
10448 
  def read(self, iprot):
10449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10451 
      return
10452 
    iprot.readStructBegin()
10453 
    while True:
10454 
      (fname, ftype, fid) = iprot.readFieldBegin()
10455 
      if ftype == TType.STOP:
10456 
        break
10457 
      if fid == 0:
10458 
        if ftype == TType.LIST:
10459 
          self.success = []
11592 amit.gupta 10460 
          (_etype135, _size132) = iprot.readListBegin()
10461 
          for _i136 in xrange(_size132):
10462 
            _elem137 = TrackLog()
10463 
            _elem137.read(iprot)
10464 
            self.success.append(_elem137)
1845 vikas 10465 
          iprot.readListEnd()
10466 
        else:
10467 
          iprot.skip(ftype)
10468 
      elif fid == 1:
10469 
        if ftype == TType.STRUCT:
1996 vikas 10470 
          self.utx = UserAffiliateException()
1845 vikas 10471 
          self.utx.read(iprot)
10472 
        else:
10473 
          iprot.skip(ftype)
10474 
      else:
10475 
        iprot.skip(ftype)
10476 
      iprot.readFieldEnd()
10477 
    iprot.readStructEnd()
10478 
 
10479 
  def write(self, oprot):
10480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10482 
      return
1996 vikas 10483 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10484 
    if self.success is not None:
1845 vikas 10485 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10486 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10487 
      for iter138 in self.success:
10488 
        iter138.write(oprot)
1845 vikas 10489 
      oprot.writeListEnd()
10490 
      oprot.writeFieldEnd()
3431 rajveer 10491 
    if self.utx is not None:
1845 vikas 10492 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10493 
      self.utx.write(oprot)
10494 
      oprot.writeFieldEnd()
10495 
    oprot.writeFieldStop()
10496 
    oprot.writeStructEnd()
10497 
 
3431 rajveer 10498 
  def validate(self):
10499 
    return
10500 
 
10501 
 
1845 vikas 10502 
  def __repr__(self):
10503 
    L = ['%s=%r' % (key, value)
10504 
      for key, value in self.__dict__.iteritems()]
10505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10506 
 
10507 
  def __eq__(self, other):
10508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10509 
 
10510 
  def __ne__(self, other):
10511 
    return not (self == other)
10512 
 
10513 
class getTrackLogsByUser_args:
10514 
  """
10515 
  Attributes:
10516 
   - userId
10517 
  """
10518 
 
10519 
  thrift_spec = (
10520 
    None, # 0
10521 
    (1, TType.I64, 'userId', None, None, ), # 1
10522 
  )
10523 
 
10524 
  def __init__(self, userId=None,):
10525 
    self.userId = userId
10526 
 
10527 
  def read(self, iprot):
10528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10530 
      return
10531 
    iprot.readStructBegin()
10532 
    while True:
10533 
      (fname, ftype, fid) = iprot.readFieldBegin()
10534 
      if ftype == TType.STOP:
10535 
        break
10536 
      if fid == 1:
10537 
        if ftype == TType.I64:
10538 
          self.userId = iprot.readI64();
10539 
        else:
10540 
          iprot.skip(ftype)
10541 
      else:
10542 
        iprot.skip(ftype)
10543 
      iprot.readFieldEnd()
10544 
    iprot.readStructEnd()
10545 
 
10546 
  def write(self, oprot):
10547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10549 
      return
10550 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10551 
    if self.userId is not None:
1845 vikas 10552 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10553 
      oprot.writeI64(self.userId)
10554 
      oprot.writeFieldEnd()
10555 
    oprot.writeFieldStop()
10556 
    oprot.writeStructEnd()
10557 
 
3431 rajveer 10558 
  def validate(self):
10559 
    return
10560 
 
10561 
 
1845 vikas 10562 
  def __repr__(self):
10563 
    L = ['%s=%r' % (key, value)
10564 
      for key, value in self.__dict__.iteritems()]
10565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10566 
 
10567 
  def __eq__(self, other):
10568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10569 
 
10570 
  def __ne__(self, other):
10571 
    return not (self == other)
10572 
 
10573 
class getTrackLogsByUser_result:
10574 
  """
10575 
  Attributes:
10576 
   - success
10577 
   - utx
10578 
  """
10579 
 
10580 
  thrift_spec = (
10581 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10582 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10583 
  )
10584 
 
10585 
  def __init__(self, success=None, utx=None,):
10586 
    self.success = success
10587 
    self.utx = utx
10588 
 
10589 
  def read(self, iprot):
10590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10592 
      return
10593 
    iprot.readStructBegin()
10594 
    while True:
10595 
      (fname, ftype, fid) = iprot.readFieldBegin()
10596 
      if ftype == TType.STOP:
10597 
        break
10598 
      if fid == 0:
10599 
        if ftype == TType.LIST:
10600 
          self.success = []
11592 amit.gupta 10601 
          (_etype142, _size139) = iprot.readListBegin()
10602 
          for _i143 in xrange(_size139):
10603 
            _elem144 = TrackLog()
10604 
            _elem144.read(iprot)
10605 
            self.success.append(_elem144)
1845 vikas 10606 
          iprot.readListEnd()
10607 
        else:
10608 
          iprot.skip(ftype)
10609 
      elif fid == 1:
10610 
        if ftype == TType.STRUCT:
1996 vikas 10611 
          self.utx = UserAffiliateException()
1845 vikas 10612 
          self.utx.read(iprot)
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      else:
10616 
        iprot.skip(ftype)
10617 
      iprot.readFieldEnd()
10618 
    iprot.readStructEnd()
10619 
 
10620 
  def write(self, oprot):
10621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10623 
      return
10624 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10625 
    if self.success is not None:
1845 vikas 10626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10627 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10628 
      for iter145 in self.success:
10629 
        iter145.write(oprot)
1845 vikas 10630 
      oprot.writeListEnd()
10631 
      oprot.writeFieldEnd()
3431 rajveer 10632 
    if self.utx is not None:
1845 vikas 10633 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10634 
      self.utx.write(oprot)
10635 
      oprot.writeFieldEnd()
10636 
    oprot.writeFieldStop()
10637 
    oprot.writeStructEnd()
10638 
 
3431 rajveer 10639 
  def validate(self):
10640 
    return
10641 
 
10642 
 
1845 vikas 10643 
  def __repr__(self):
10644 
    L = ['%s=%r' % (key, value)
10645 
      for key, value in self.__dict__.iteritems()]
10646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10647 
 
10648 
  def __eq__(self, other):
10649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10650 
 
10651 
  def __ne__(self, other):
10652 
    return not (self == other)
10653 
 
10654 
class getTrackLogs_args:
10655 
  """
10656 
  Attributes:
10657 
   - userId
10658 
   - event
10659 
   - url
10660 
  """
10661 
 
10662 
  thrift_spec = (
10663 
    None, # 0
1996 vikas 10664 
    (1, TType.I64, 'userId', None, None, ), # 1
10665 
    (2, TType.STRING, 'event', None, None, ), # 2
10666 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10667 
  )
10668 
 
1996 vikas 10669 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10670 
    self.userId = userId
10671 
    self.event = event
10672 
    self.url = url
10673 
 
10674 
  def read(self, iprot):
10675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10677 
      return
10678 
    iprot.readStructBegin()
10679 
    while True:
10680 
      (fname, ftype, fid) = iprot.readFieldBegin()
10681 
      if ftype == TType.STOP:
10682 
        break
10683 
      if fid == 1:
10684 
        if ftype == TType.I64:
1996 vikas 10685 
          self.userId = iprot.readI64();
1845 vikas 10686 
        else:
10687 
          iprot.skip(ftype)
10688 
      elif fid == 2:
10689 
        if ftype == TType.STRING:
10690 
          self.event = iprot.readString();
10691 
        else:
10692 
          iprot.skip(ftype)
1996 vikas 10693 
      elif fid == 3:
1845 vikas 10694 
        if ftype == TType.STRING:
10695 
          self.url = iprot.readString();
10696 
        else:
10697 
          iprot.skip(ftype)
10698 
      else:
10699 
        iprot.skip(ftype)
10700 
      iprot.readFieldEnd()
10701 
    iprot.readStructEnd()
10702 
 
10703 
  def write(self, oprot):
10704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10706 
      return
10707 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10708 
    if self.userId is not None:
1996 vikas 10709 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10710 
      oprot.writeI64(self.userId)
10711 
      oprot.writeFieldEnd()
3431 rajveer 10712 
    if self.event is not None:
1996 vikas 10713 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10714 
      oprot.writeString(self.event)
10715 
      oprot.writeFieldEnd()
3431 rajveer 10716 
    if self.url is not None:
1996 vikas 10717 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10718 
      oprot.writeString(self.url)
10719 
      oprot.writeFieldEnd()
10720 
    oprot.writeFieldStop()
10721 
    oprot.writeStructEnd()
10722 
 
3431 rajveer 10723 
  def validate(self):
10724 
    return
10725 
 
10726 
 
1845 vikas 10727 
  def __repr__(self):
10728 
    L = ['%s=%r' % (key, value)
10729 
      for key, value in self.__dict__.iteritems()]
10730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10731 
 
10732 
  def __eq__(self, other):
10733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10734 
 
10735 
  def __ne__(self, other):
10736 
    return not (self == other)
10737 
 
10738 
class getTrackLogs_result:
10739 
  """
10740 
  Attributes:
10741 
   - success
10742 
   - utx
10743 
  """
10744 
 
10745 
  thrift_spec = (
10746 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10747 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10748 
  )
10749 
 
10750 
  def __init__(self, success=None, utx=None,):
10751 
    self.success = success
10752 
    self.utx = utx
10753 
 
10754 
  def read(self, iprot):
10755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10757 
      return
10758 
    iprot.readStructBegin()
10759 
    while True:
10760 
      (fname, ftype, fid) = iprot.readFieldBegin()
10761 
      if ftype == TType.STOP:
10762 
        break
10763 
      if fid == 0:
10764 
        if ftype == TType.LIST:
10765 
          self.success = []
11592 amit.gupta 10766 
          (_etype149, _size146) = iprot.readListBegin()
10767 
          for _i150 in xrange(_size146):
10768 
            _elem151 = TrackLog()
10769 
            _elem151.read(iprot)
10770 
            self.success.append(_elem151)
1845 vikas 10771 
          iprot.readListEnd()
10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      elif fid == 1:
10775 
        if ftype == TType.STRUCT:
1996 vikas 10776 
          self.utx = UserAffiliateException()
1845 vikas 10777 
          self.utx.read(iprot)
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
10789 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10790 
    if self.success is not None:
1845 vikas 10791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10792 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10793 
      for iter152 in self.success:
10794 
        iter152.write(oprot)
1845 vikas 10795 
      oprot.writeListEnd()
10796 
      oprot.writeFieldEnd()
3431 rajveer 10797 
    if self.utx is not None:
1845 vikas 10798 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10799 
      self.utx.write(oprot)
10800 
      oprot.writeFieldEnd()
10801 
    oprot.writeFieldStop()
10802 
    oprot.writeStructEnd()
10803 
 
3431 rajveer 10804 
  def validate(self):
10805 
    return
10806 
 
10807 
 
1845 vikas 10808 
  def __repr__(self):
10809 
    L = ['%s=%r' % (key, value)
10810 
      for key, value in self.__dict__.iteritems()]
10811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10812 
 
10813 
  def __eq__(self, other):
10814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10815 
 
10816 
  def __ne__(self, other):
10817 
    return not (self == other)
10818 
 
559 chandransh 10819 
class getCurrentCart_args:
94 ashish 10820 
  """
10821 
  Attributes:
559 chandransh 10822 
   - userId
10823 
  """
10824 
 
10825 
  thrift_spec = (
10826 
    None, # 0
10827 
    (1, TType.I64, 'userId', None, None, ), # 1
10828 
  )
10829 
 
10830 
  def __init__(self, userId=None,):
10831 
    self.userId = userId
10832 
 
10833 
  def read(self, iprot):
10834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10836 
      return
10837 
    iprot.readStructBegin()
10838 
    while True:
10839 
      (fname, ftype, fid) = iprot.readFieldBegin()
10840 
      if ftype == TType.STOP:
10841 
        break
10842 
      if fid == 1:
10843 
        if ftype == TType.I64:
10844 
          self.userId = iprot.readI64();
10845 
        else:
10846 
          iprot.skip(ftype)
10847 
      else:
10848 
        iprot.skip(ftype)
10849 
      iprot.readFieldEnd()
10850 
    iprot.readStructEnd()
10851 
 
10852 
  def write(self, oprot):
10853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10855 
      return
10856 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10857 
    if self.userId is not None:
559 chandransh 10858 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10859 
      oprot.writeI64(self.userId)
10860 
      oprot.writeFieldEnd()
10861 
    oprot.writeFieldStop()
10862 
    oprot.writeStructEnd()
10863 
 
3431 rajveer 10864 
  def validate(self):
10865 
    return
10866 
 
10867 
 
559 chandransh 10868 
  def __repr__(self):
10869 
    L = ['%s=%r' % (key, value)
10870 
      for key, value in self.__dict__.iteritems()]
10871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10872 
 
10873 
  def __eq__(self, other):
10874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10875 
 
10876 
  def __ne__(self, other):
10877 
    return not (self == other)
10878 
 
10879 
class getCurrentCart_result:
10880 
  """
10881 
  Attributes:
94 ashish 10882 
   - success
559 chandransh 10883 
   - scx
94 ashish 10884 
  """
10885 
 
10886 
  thrift_spec = (
559 chandransh 10887 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10888 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10889 
  )
10890 
 
559 chandransh 10891 
  def __init__(self, success=None, scx=None,):
94 ashish 10892 
    self.success = success
559 chandransh 10893 
    self.scx = scx
94 ashish 10894 
 
10895 
  def read(self, iprot):
10896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10898 
      return
10899 
    iprot.readStructBegin()
10900 
    while True:
10901 
      (fname, ftype, fid) = iprot.readFieldBegin()
10902 
      if ftype == TType.STOP:
10903 
        break
10904 
      if fid == 0:
559 chandransh 10905 
        if ftype == TType.STRUCT:
10906 
          self.success = Cart()
10907 
          self.success.read(iprot)
94 ashish 10908 
        else:
10909 
          iprot.skip(ftype)
10910 
      elif fid == 1:
10911 
        if ftype == TType.STRUCT:
559 chandransh 10912 
          self.scx = ShoppingCartException()
10913 
          self.scx.read(iprot)
94 ashish 10914 
        else:
10915 
          iprot.skip(ftype)
10916 
      else:
10917 
        iprot.skip(ftype)
10918 
      iprot.readFieldEnd()
10919 
    iprot.readStructEnd()
10920 
 
10921 
  def write(self, oprot):
10922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10924 
      return
559 chandransh 10925 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10926 
    if self.success is not None:
559 chandransh 10927 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10928 
      self.success.write(oprot)
94 ashish 10929 
      oprot.writeFieldEnd()
3431 rajveer 10930 
    if self.scx is not None:
559 chandransh 10931 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10932 
      self.scx.write(oprot)
94 ashish 10933 
      oprot.writeFieldEnd()
10934 
    oprot.writeFieldStop()
10935 
    oprot.writeStructEnd()
10936 
 
3431 rajveer 10937 
  def validate(self):
10938 
    return
10939 
 
10940 
 
94 ashish 10941 
  def __repr__(self):
10942 
    L = ['%s=%r' % (key, value)
10943 
      for key, value in self.__dict__.iteritems()]
10944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10945 
 
10946 
  def __eq__(self, other):
10947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10948 
 
10949 
  def __ne__(self, other):
10950 
    return not (self == other)
10951 
 
559 chandransh 10952 
class getCart_args:
504 rajveer 10953 
  """
10954 
  Attributes:
559 chandransh 10955 
   - cartId
504 rajveer 10956 
  """
10957 
 
10958 
  thrift_spec = (
10959 
    None, # 0
559 chandransh 10960 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10961 
  )
10962 
 
559 chandransh 10963 
  def __init__(self, cartId=None,):
10964 
    self.cartId = cartId
504 rajveer 10965 
 
10966 
  def read(self, iprot):
10967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10969 
      return
10970 
    iprot.readStructBegin()
10971 
    while True:
10972 
      (fname, ftype, fid) = iprot.readFieldBegin()
10973 
      if ftype == TType.STOP:
10974 
        break
10975 
      if fid == 1:
10976 
        if ftype == TType.I64:
559 chandransh 10977 
          self.cartId = iprot.readI64();
504 rajveer 10978 
        else:
10979 
          iprot.skip(ftype)
10980 
      else:
10981 
        iprot.skip(ftype)
10982 
      iprot.readFieldEnd()
10983 
    iprot.readStructEnd()
10984 
 
10985 
  def write(self, oprot):
10986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10988 
      return
559 chandransh 10989 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10990 
    if self.cartId is not None:
559 chandransh 10991 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10992 
      oprot.writeI64(self.cartId)
504 rajveer 10993 
      oprot.writeFieldEnd()
10994 
    oprot.writeFieldStop()
10995 
    oprot.writeStructEnd()
10996 
 
3431 rajveer 10997 
  def validate(self):
10998 
    return
10999 
 
11000 
 
504 rajveer 11001 
  def __repr__(self):
11002 
    L = ['%s=%r' % (key, value)
11003 
      for key, value in self.__dict__.iteritems()]
11004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11005 
 
11006 
  def __eq__(self, other):
11007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11008 
 
11009 
  def __ne__(self, other):
11010 
    return not (self == other)
11011 
 
559 chandransh 11012 
class getCart_result:
504 rajveer 11013 
  """
11014 
  Attributes:
11015 
   - success
559 chandransh 11016 
   - scx
504 rajveer 11017 
  """
11018 
 
11019 
  thrift_spec = (
559 chandransh 11020 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
11021 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 11022 
  )
11023 
 
559 chandransh 11024 
  def __init__(self, success=None, scx=None,):
504 rajveer 11025 
    self.success = success
559 chandransh 11026 
    self.scx = scx
504 rajveer 11027 
 
11028 
  def read(self, iprot):
11029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11031 
      return
11032 
    iprot.readStructBegin()
11033 
    while True:
11034 
      (fname, ftype, fid) = iprot.readFieldBegin()
11035 
      if ftype == TType.STOP:
11036 
        break
11037 
      if fid == 0:
559 chandransh 11038 
        if ftype == TType.STRUCT:
11039 
          self.success = Cart()
11040 
          self.success.read(iprot)
504 rajveer 11041 
        else:
11042 
          iprot.skip(ftype)
11043 
      elif fid == 1:
11044 
        if ftype == TType.STRUCT:
559 chandransh 11045 
          self.scx = ShoppingCartException()
11046 
          self.scx.read(iprot)
504 rajveer 11047 
        else:
11048 
          iprot.skip(ftype)
11049 
      else:
11050 
        iprot.skip(ftype)
11051 
      iprot.readFieldEnd()
11052 
    iprot.readStructEnd()
11053 
 
11054 
  def write(self, oprot):
11055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11057 
      return
559 chandransh 11058 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 11059 
    if self.success is not None:
559 chandransh 11060 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11061 
      self.success.write(oprot)
504 rajveer 11062 
      oprot.writeFieldEnd()
3431 rajveer 11063 
    if self.scx is not None:
559 chandransh 11064 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11065 
      self.scx.write(oprot)
504 rajveer 11066 
      oprot.writeFieldEnd()
11067 
    oprot.writeFieldStop()
11068 
    oprot.writeStructEnd()
11069 
 
3431 rajveer 11070 
  def validate(self):
11071 
    return
11072 
 
11073 
 
504 rajveer 11074 
  def __repr__(self):
11075 
    L = ['%s=%r' % (key, value)
11076 
      for key, value in self.__dict__.iteritems()]
11077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11078 
 
11079 
  def __eq__(self, other):
11080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11081 
 
11082 
  def __ne__(self, other):
11083 
    return not (self == other)
11084 
 
559 chandransh 11085 
class getCartsByTime_args:
11086 
  """
11087 
  Attributes:
11088 
   - from_time
11089 
   - to_time
11090 
   - status
11091 
  """
11092 
 
11093 
  thrift_spec = (
11094 
    None, # 0
11095 
    (1, TType.I64, 'from_time', None, None, ), # 1
11096 
    (2, TType.I64, 'to_time', None, None, ), # 2
11097 
    (3, TType.I32, 'status', None, None, ), # 3
11098 
  )
11099 
 
11100 
  def __init__(self, from_time=None, to_time=None, status=None,):
11101 
    self.from_time = from_time
11102 
    self.to_time = to_time
11103 
    self.status = status
11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
11114 
      if fid == 1:
94 ashish 11115 
        if ftype == TType.I64:
559 chandransh 11116 
          self.from_time = iprot.readI64();
94 ashish 11117 
        else:
11118 
          iprot.skip(ftype)
122 ashish 11119 
      elif fid == 2:
559 chandransh 11120 
        if ftype == TType.I64:
11121 
          self.to_time = iprot.readI64();
122 ashish 11122 
        else:
11123 
          iprot.skip(ftype)
559 chandransh 11124 
      elif fid == 3:
11125 
        if ftype == TType.I32:
11126 
          self.status = iprot.readI32();
11127 
        else:
11128 
          iprot.skip(ftype)
94 ashish 11129 
      else:
11130 
        iprot.skip(ftype)
11131 
      iprot.readFieldEnd()
11132 
    iprot.readStructEnd()
11133 
 
11134 
  def write(self, oprot):
11135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11137 
      return
559 chandransh 11138 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11139 
    if self.from_time is not None:
559 chandransh 11140 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11141 
      oprot.writeI64(self.from_time)
94 ashish 11142 
      oprot.writeFieldEnd()
3431 rajveer 11143 
    if self.to_time is not None:
559 chandransh 11144 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11145 
      oprot.writeI64(self.to_time)
122 ashish 11146 
      oprot.writeFieldEnd()
3431 rajveer 11147 
    if self.status is not None:
559 chandransh 11148 
      oprot.writeFieldBegin('status', TType.I32, 3)
11149 
      oprot.writeI32(self.status)
11150 
      oprot.writeFieldEnd()
94 ashish 11151 
    oprot.writeFieldStop()
11152 
    oprot.writeStructEnd()
11153 
 
3431 rajveer 11154 
  def validate(self):
11155 
    return
11156 
 
11157 
 
94 ashish 11158 
  def __repr__(self):
11159 
    L = ['%s=%r' % (key, value)
11160 
      for key, value in self.__dict__.iteritems()]
11161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11162 
 
11163 
  def __eq__(self, other):
11164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11165 
 
11166 
  def __ne__(self, other):
11167 
    return not (self == other)
11168 
 
559 chandransh 11169 
class getCartsByTime_result:
94 ashish 11170 
  """
11171 
  Attributes:
11172 
   - success
559 chandransh 11173 
   - scx
94 ashish 11174 
  """
11175 
 
11176 
  thrift_spec = (
559 chandransh 11177 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11178 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11179 
  )
11180 
 
559 chandransh 11181 
  def __init__(self, success=None, scx=None,):
94 ashish 11182 
    self.success = success
559 chandransh 11183 
    self.scx = scx
94 ashish 11184 
 
11185 
  def read(self, iprot):
11186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11188 
      return
11189 
    iprot.readStructBegin()
11190 
    while True:
11191 
      (fname, ftype, fid) = iprot.readFieldBegin()
11192 
      if ftype == TType.STOP:
11193 
        break
11194 
      if fid == 0:
559 chandransh 11195 
        if ftype == TType.LIST:
11196 
          self.success = []
11592 amit.gupta 11197 
          (_etype156, _size153) = iprot.readListBegin()
11198 
          for _i157 in xrange(_size153):
11199 
            _elem158 = Cart()
11200 
            _elem158.read(iprot)
11201 
            self.success.append(_elem158)
559 chandransh 11202 
          iprot.readListEnd()
94 ashish 11203 
        else:
11204 
          iprot.skip(ftype)
11205 
      elif fid == 1:
11206 
        if ftype == TType.STRUCT:
559 chandransh 11207 
          self.scx = ShoppingCartException()
11208 
          self.scx.read(iprot)
94 ashish 11209 
        else:
11210 
          iprot.skip(ftype)
11211 
      else:
11212 
        iprot.skip(ftype)
11213 
      iprot.readFieldEnd()
11214 
    iprot.readStructEnd()
11215 
 
11216 
  def write(self, oprot):
11217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11219 
      return
559 chandransh 11220 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11221 
    if self.success is not None:
559 chandransh 11222 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11223 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11224 
      for iter159 in self.success:
11225 
        iter159.write(oprot)
559 chandransh 11226 
      oprot.writeListEnd()
94 ashish 11227 
      oprot.writeFieldEnd()
3431 rajveer 11228 
    if self.scx is not None:
559 chandransh 11229 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11230 
      self.scx.write(oprot)
94 ashish 11231 
      oprot.writeFieldEnd()
11232 
    oprot.writeFieldStop()
11233 
    oprot.writeStructEnd()
11234 
 
3431 rajveer 11235 
  def validate(self):
11236 
    return
11237 
 
11238 
 
94 ashish 11239 
  def __repr__(self):
11240 
    L = ['%s=%r' % (key, value)
11241 
      for key, value in self.__dict__.iteritems()]
11242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11243 
 
11244 
  def __eq__(self, other):
11245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11246 
 
11247 
  def __ne__(self, other):
11248 
    return not (self == other)
11249 
 
559 chandransh 11250 
class addItemToCart_args:
11251 
  """
11252 
  Attributes:
11253 
   - cartId
11254 
   - itemId
11255 
   - quantity
3557 rajveer 11256 
   - sourceId
559 chandransh 11257 
  """
11258 
 
11259 
  thrift_spec = (
11260 
    None, # 0
11261 
    (1, TType.I64, 'cartId', None, None, ), # 1
11262 
    (2, TType.I64, 'itemId', None, None, ), # 2
11263 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11264 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11265 
  )
11266 
 
3557 rajveer 11267 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11268 
    self.cartId = cartId
11269 
    self.itemId = itemId
11270 
    self.quantity = quantity
3557 rajveer 11271 
    self.sourceId = sourceId
559 chandransh 11272 
 
11273 
  def read(self, iprot):
11274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11276 
      return
11277 
    iprot.readStructBegin()
11278 
    while True:
11279 
      (fname, ftype, fid) = iprot.readFieldBegin()
11280 
      if ftype == TType.STOP:
11281 
        break
11282 
      if fid == 1:
11283 
        if ftype == TType.I64:
11284 
          self.cartId = iprot.readI64();
11285 
        else:
11286 
          iprot.skip(ftype)
11287 
      elif fid == 2:
11288 
        if ftype == TType.I64:
11289 
          self.itemId = iprot.readI64();
11290 
        else:
11291 
          iprot.skip(ftype)
11292 
      elif fid == 3:
11293 
        if ftype == TType.I64:
11294 
          self.quantity = iprot.readI64();
11295 
        else:
11296 
          iprot.skip(ftype)
3557 rajveer 11297 
      elif fid == 4:
11298 
        if ftype == TType.I64:
11299 
          self.sourceId = iprot.readI64();
11300 
        else:
11301 
          iprot.skip(ftype)
559 chandransh 11302 
      else:
11303 
        iprot.skip(ftype)
11304 
      iprot.readFieldEnd()
11305 
    iprot.readStructEnd()
11306 
 
11307 
  def write(self, oprot):
11308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11310 
      return
11311 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11312 
    if self.cartId is not None:
559 chandransh 11313 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11314 
      oprot.writeI64(self.cartId)
11315 
      oprot.writeFieldEnd()
3431 rajveer 11316 
    if self.itemId is not None:
559 chandransh 11317 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11318 
      oprot.writeI64(self.itemId)
11319 
      oprot.writeFieldEnd()
3431 rajveer 11320 
    if self.quantity is not None:
559 chandransh 11321 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11322 
      oprot.writeI64(self.quantity)
11323 
      oprot.writeFieldEnd()
3557 rajveer 11324 
    if self.sourceId is not None:
11325 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11326 
      oprot.writeI64(self.sourceId)
11327 
      oprot.writeFieldEnd()
559 chandransh 11328 
    oprot.writeFieldStop()
11329 
    oprot.writeStructEnd()
11330 
 
3431 rajveer 11331 
  def validate(self):
11332 
    return
11333 
 
11334 
 
559 chandransh 11335 
  def __repr__(self):
11336 
    L = ['%s=%r' % (key, value)
11337 
      for key, value in self.__dict__.iteritems()]
11338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11339 
 
11340 
  def __eq__(self, other):
11341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11342 
 
11343 
  def __ne__(self, other):
11344 
    return not (self == other)
11345 
 
11346 
class addItemToCart_result:
11347 
  """
11348 
  Attributes:
2035 rajveer 11349 
   - success
559 chandransh 11350 
   - scx
11351 
  """
11352 
 
11353 
  thrift_spec = (
2035 rajveer 11354 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11355 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11356 
  )
11357 
 
2035 rajveer 11358 
  def __init__(self, success=None, scx=None,):
11359 
    self.success = success
559 chandransh 11360 
    self.scx = scx
11361 
 
11362 
  def read(self, iprot):
11363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11365 
      return
11366 
    iprot.readStructBegin()
11367 
    while True:
11368 
      (fname, ftype, fid) = iprot.readFieldBegin()
11369 
      if ftype == TType.STOP:
11370 
        break
2035 rajveer 11371 
      if fid == 0:
11372 
        if ftype == TType.STRING:
11373 
          self.success = iprot.readString();
11374 
        else:
11375 
          iprot.skip(ftype)
11376 
      elif fid == 1:
559 chandransh 11377 
        if ftype == TType.STRUCT:
11378 
          self.scx = ShoppingCartException()
11379 
          self.scx.read(iprot)
11380 
        else:
11381 
          iprot.skip(ftype)
11382 
      else:
11383 
        iprot.skip(ftype)
11384 
      iprot.readFieldEnd()
11385 
    iprot.readStructEnd()
11386 
 
11387 
  def write(self, oprot):
11388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11390 
      return
11391 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11392 
    if self.success is not None:
2035 rajveer 11393 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11394 
      oprot.writeString(self.success)
11395 
      oprot.writeFieldEnd()
3431 rajveer 11396 
    if self.scx is not None:
559 chandransh 11397 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11398 
      self.scx.write(oprot)
11399 
      oprot.writeFieldEnd()
11400 
    oprot.writeFieldStop()
11401 
    oprot.writeStructEnd()
11402 
 
3431 rajveer 11403 
  def validate(self):
11404 
    return
11405 
 
11406 
 
559 chandransh 11407 
  def __repr__(self):
11408 
    L = ['%s=%r' % (key, value)
11409 
      for key, value in self.__dict__.iteritems()]
11410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11411 
 
11412 
  def __eq__(self, other):
11413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11414 
 
11415 
  def __ne__(self, other):
11416 
    return not (self == other)
11417 
 
11418 
class deleteItemFromCart_args:
11419 
  """
11420 
  Attributes:
11421 
   - cartId
11422 
   - itemId
11423 
  """
11424 
 
11425 
  thrift_spec = (
11426 
    None, # 0
11427 
    (1, TType.I64, 'cartId', None, None, ), # 1
11428 
    (2, TType.I64, 'itemId', None, None, ), # 2
11429 
  )
11430 
 
11431 
  def __init__(self, cartId=None, itemId=None,):
11432 
    self.cartId = cartId
11433 
    self.itemId = itemId
11434 
 
11435 
  def read(self, iprot):
11436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11438 
      return
11439 
    iprot.readStructBegin()
11440 
    while True:
11441 
      (fname, ftype, fid) = iprot.readFieldBegin()
11442 
      if ftype == TType.STOP:
11443 
        break
11444 
      if fid == 1:
11445 
        if ftype == TType.I64:
11446 
          self.cartId = iprot.readI64();
11447 
        else:
11448 
          iprot.skip(ftype)
11449 
      elif fid == 2:
11450 
        if ftype == TType.I64:
11451 
          self.itemId = iprot.readI64();
11452 
        else:
11453 
          iprot.skip(ftype)
11454 
      else:
11455 
        iprot.skip(ftype)
11456 
      iprot.readFieldEnd()
11457 
    iprot.readStructEnd()
11458 
 
11459 
  def write(self, oprot):
11460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11462 
      return
11463 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11464 
    if self.cartId is not None:
559 chandransh 11465 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11466 
      oprot.writeI64(self.cartId)
11467 
      oprot.writeFieldEnd()
3431 rajveer 11468 
    if self.itemId is not None:
559 chandransh 11469 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11470 
      oprot.writeI64(self.itemId)
11471 
      oprot.writeFieldEnd()
11472 
    oprot.writeFieldStop()
11473 
    oprot.writeStructEnd()
11474 
 
3431 rajveer 11475 
  def validate(self):
11476 
    return
11477 
 
11478 
 
559 chandransh 11479 
  def __repr__(self):
11480 
    L = ['%s=%r' % (key, value)
11481 
      for key, value in self.__dict__.iteritems()]
11482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11483 
 
11484 
  def __eq__(self, other):
11485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11486 
 
11487 
  def __ne__(self, other):
11488 
    return not (self == other)
11489 
 
11490 
class deleteItemFromCart_result:
11491 
  """
11492 
  Attributes:
11493 
   - scx
11494 
  """
11495 
 
11496 
  thrift_spec = (
11497 
    None, # 0
11498 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11499 
  )
11500 
 
11501 
  def __init__(self, scx=None,):
11502 
    self.scx = scx
11503 
 
11504 
  def read(self, iprot):
11505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11507 
      return
11508 
    iprot.readStructBegin()
11509 
    while True:
11510 
      (fname, ftype, fid) = iprot.readFieldBegin()
11511 
      if ftype == TType.STOP:
11512 
        break
11513 
      if fid == 1:
11514 
        if ftype == TType.STRUCT:
11515 
          self.scx = ShoppingCartException()
11516 
          self.scx.read(iprot)
11517 
        else:
11518 
          iprot.skip(ftype)
11519 
      else:
11520 
        iprot.skip(ftype)
11521 
      iprot.readFieldEnd()
11522 
    iprot.readStructEnd()
11523 
 
11524 
  def write(self, oprot):
11525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11527 
      return
11528 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11529 
    if self.scx is not None:
559 chandransh 11530 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11531 
      self.scx.write(oprot)
11532 
      oprot.writeFieldEnd()
11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
3431 rajveer 11536 
  def validate(self):
11537 
    return
11538 
 
11539 
 
559 chandransh 11540 
  def __repr__(self):
11541 
    L = ['%s=%r' % (key, value)
11542 
      for key, value in self.__dict__.iteritems()]
11543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11544 
 
11545 
  def __eq__(self, other):
11546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11547 
 
11548 
  def __ne__(self, other):
11549 
    return not (self == other)
11550 
 
11551 
class addAddressToCart_args:
11552 
  """
11553 
  Attributes:
11554 
   - cartId
11555 
   - addressId
11556 
  """
11557 
 
11558 
  thrift_spec = (
11559 
    None, # 0
11560 
    (1, TType.I64, 'cartId', None, None, ), # 1
11561 
    (2, TType.I64, 'addressId', None, None, ), # 2
11562 
  )
11563 
 
11564 
  def __init__(self, cartId=None, addressId=None,):
11565 
    self.cartId = cartId
11566 
    self.addressId = addressId
11567 
 
11568 
  def read(self, iprot):
11569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11571 
      return
11572 
    iprot.readStructBegin()
11573 
    while True:
11574 
      (fname, ftype, fid) = iprot.readFieldBegin()
11575 
      if ftype == TType.STOP:
11576 
        break
11577 
      if fid == 1:
11578 
        if ftype == TType.I64:
11579 
          self.cartId = iprot.readI64();
11580 
        else:
11581 
          iprot.skip(ftype)
11582 
      elif fid == 2:
11583 
        if ftype == TType.I64:
11584 
          self.addressId = iprot.readI64();
11585 
        else:
11586 
          iprot.skip(ftype)
11587 
      else:
11588 
        iprot.skip(ftype)
11589 
      iprot.readFieldEnd()
11590 
    iprot.readStructEnd()
11591 
 
11592 
  def write(self, oprot):
11593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11595 
      return
11596 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11597 
    if self.cartId is not None:
559 chandransh 11598 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11599 
      oprot.writeI64(self.cartId)
11600 
      oprot.writeFieldEnd()
3431 rajveer 11601 
    if self.addressId is not None:
559 chandransh 11602 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11603 
      oprot.writeI64(self.addressId)
11604 
      oprot.writeFieldEnd()
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
3431 rajveer 11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
559 chandransh 11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class addAddressToCart_result:
575 chandransh 11624 
  """
11625 
  Attributes:
11626 
   - scx
11627 
  """
559 chandransh 11628 
 
11629 
  thrift_spec = (
575 chandransh 11630 
    None, # 0
11631 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11632 
  )
11633 
 
575 chandransh 11634 
  def __init__(self, scx=None,):
11635 
    self.scx = scx
11636 
 
559 chandransh 11637 
  def read(self, iprot):
11638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11640 
      return
11641 
    iprot.readStructBegin()
11642 
    while True:
11643 
      (fname, ftype, fid) = iprot.readFieldBegin()
11644 
      if ftype == TType.STOP:
11645 
        break
575 chandransh 11646 
      if fid == 1:
11647 
        if ftype == TType.STRUCT:
11648 
          self.scx = ShoppingCartException()
11649 
          self.scx.read(iprot)
11650 
        else:
11651 
          iprot.skip(ftype)
559 chandransh 11652 
      else:
11653 
        iprot.skip(ftype)
11654 
      iprot.readFieldEnd()
11655 
    iprot.readStructEnd()
11656 
 
11657 
  def write(self, oprot):
11658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11660 
      return
11661 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11662 
    if self.scx is not None:
575 chandransh 11663 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11664 
      self.scx.write(oprot)
11665 
      oprot.writeFieldEnd()
559 chandransh 11666 
    oprot.writeFieldStop()
11667 
    oprot.writeStructEnd()
11668 
 
3431 rajveer 11669 
  def validate(self):
11670 
    return
11671 
 
11672 
 
559 chandransh 11673 
  def __repr__(self):
11674 
    L = ['%s=%r' % (key, value)
11675 
      for key, value in self.__dict__.iteritems()]
11676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11677 
 
11678 
  def __eq__(self, other):
11679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11680 
 
11681 
  def __ne__(self, other):
11682 
    return not (self == other)
11683 
 
5553 rajveer 11684 
class addStoreToCart_args:
11685 
  """
11686 
  Attributes:
11687 
   - cartId
11688 
   - storeId
11689 
  """
11690 
 
11691 
  thrift_spec = (
11692 
    None, # 0
11693 
    (1, TType.I64, 'cartId', None, None, ), # 1
11694 
    (2, TType.I64, 'storeId', None, None, ), # 2
11695 
  )
11696 
 
11697 
  def __init__(self, cartId=None, storeId=None,):
11698 
    self.cartId = cartId
11699 
    self.storeId = storeId
11700 
 
11701 
  def read(self, iprot):
11702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11704 
      return
11705 
    iprot.readStructBegin()
11706 
    while True:
11707 
      (fname, ftype, fid) = iprot.readFieldBegin()
11708 
      if ftype == TType.STOP:
11709 
        break
11710 
      if fid == 1:
11711 
        if ftype == TType.I64:
11712 
          self.cartId = iprot.readI64();
11713 
        else:
11714 
          iprot.skip(ftype)
11715 
      elif fid == 2:
11716 
        if ftype == TType.I64:
11717 
          self.storeId = iprot.readI64();
11718 
        else:
11719 
          iprot.skip(ftype)
11720 
      else:
11721 
        iprot.skip(ftype)
11722 
      iprot.readFieldEnd()
11723 
    iprot.readStructEnd()
11724 
 
11725 
  def write(self, oprot):
11726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11728 
      return
11729 
    oprot.writeStructBegin('addStoreToCart_args')
11730 
    if self.cartId is not None:
11731 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11732 
      oprot.writeI64(self.cartId)
11733 
      oprot.writeFieldEnd()
11734 
    if self.storeId is not None:
11735 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11736 
      oprot.writeI64(self.storeId)
11737 
      oprot.writeFieldEnd()
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
11756 
class addStoreToCart_result:
11757 
  """
11758 
  Attributes:
11759 
   - scx
11760 
  """
11761 
 
11762 
  thrift_spec = (
11763 
    None, # 0
11764 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11765 
  )
11766 
 
11767 
  def __init__(self, scx=None,):
11768 
    self.scx = scx
11769 
 
11770 
  def read(self, iprot):
11771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11773 
      return
11774 
    iprot.readStructBegin()
11775 
    while True:
11776 
      (fname, ftype, fid) = iprot.readFieldBegin()
11777 
      if ftype == TType.STOP:
11778 
        break
11779 
      if fid == 1:
11780 
        if ftype == TType.STRUCT:
11781 
          self.scx = ShoppingCartException()
11782 
          self.scx.read(iprot)
11783 
        else:
11784 
          iprot.skip(ftype)
11785 
      else:
11786 
        iprot.skip(ftype)
11787 
      iprot.readFieldEnd()
11788 
    iprot.readStructEnd()
11789 
 
11790 
  def write(self, oprot):
11791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11793 
      return
11794 
    oprot.writeStructBegin('addStoreToCart_result')
11795 
    if self.scx is not None:
11796 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11797 
      self.scx.write(oprot)
11798 
      oprot.writeFieldEnd()
11799 
    oprot.writeFieldStop()
11800 
    oprot.writeStructEnd()
11801 
 
11802 
  def validate(self):
11803 
    return
11804 
 
11805 
 
11806 
  def __repr__(self):
11807 
    L = ['%s=%r' % (key, value)
11808 
      for key, value in self.__dict__.iteritems()]
11809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11810 
 
11811 
  def __eq__(self, other):
11812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11813 
 
11814 
  def __ne__(self, other):
11815 
    return not (self == other)
11816 
 
1976 varun.gupt 11817 
class applyCouponToCart_args:
11818 
  """
11819 
  Attributes:
6922 anupam.sin 11820 
   - cart
1976 varun.gupt 11821 
   - couponCode
11822 
  """
11823 
 
11824 
  thrift_spec = (
11825 
    None, # 0
6922 anupam.sin 11826 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11827 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11828 
  )
11829 
 
6922 anupam.sin 11830 
  def __init__(self, cart=None, couponCode=None,):
11831 
    self.cart = cart
1976 varun.gupt 11832 
    self.couponCode = couponCode
11833 
 
11834 
  def read(self, iprot):
11835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11837 
      return
11838 
    iprot.readStructBegin()
11839 
    while True:
11840 
      (fname, ftype, fid) = iprot.readFieldBegin()
11841 
      if ftype == TType.STOP:
11842 
        break
11843 
      if fid == 1:
6922 anupam.sin 11844 
        if ftype == TType.STRUCT:
11845 
          self.cart = Cart()
11846 
          self.cart.read(iprot)
1976 varun.gupt 11847 
        else:
11848 
          iprot.skip(ftype)
11849 
      elif fid == 2:
11850 
        if ftype == TType.STRING:
11851 
          self.couponCode = iprot.readString();
11852 
        else:
11853 
          iprot.skip(ftype)
11854 
      else:
11855 
        iprot.skip(ftype)
11856 
      iprot.readFieldEnd()
11857 
    iprot.readStructEnd()
11858 
 
11859 
  def write(self, oprot):
11860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11862 
      return
11863 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11864 
    if self.cart is not None:
11865 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11866 
      self.cart.write(oprot)
1976 varun.gupt 11867 
      oprot.writeFieldEnd()
3431 rajveer 11868 
    if self.couponCode is not None:
1976 varun.gupt 11869 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11870 
      oprot.writeString(self.couponCode)
11871 
      oprot.writeFieldEnd()
11872 
    oprot.writeFieldStop()
11873 
    oprot.writeStructEnd()
11874 
 
3431 rajveer 11875 
  def validate(self):
11876 
    return
11877 
 
11878 
 
1976 varun.gupt 11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
11890 
class applyCouponToCart_result:
11891 
  """
11892 
  Attributes:
11893 
   - scx
11894 
  """
11895 
 
11896 
  thrift_spec = (
11897 
    None, # 0
11898 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11899 
  )
11900 
 
11901 
  def __init__(self, scx=None,):
11902 
    self.scx = scx
11903 
 
11904 
  def read(self, iprot):
11905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11907 
      return
11908 
    iprot.readStructBegin()
11909 
    while True:
11910 
      (fname, ftype, fid) = iprot.readFieldBegin()
11911 
      if ftype == TType.STOP:
11912 
        break
11913 
      if fid == 1:
11914 
        if ftype == TType.STRUCT:
11915 
          self.scx = ShoppingCartException()
11916 
          self.scx.read(iprot)
11917 
        else:
11918 
          iprot.skip(ftype)
11919 
      else:
11920 
        iprot.skip(ftype)
11921 
      iprot.readFieldEnd()
11922 
    iprot.readStructEnd()
11923 
 
11924 
  def write(self, oprot):
11925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11927 
      return
11928 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11929 
    if self.scx is not None:
1976 varun.gupt 11930 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11931 
      self.scx.write(oprot)
11932 
      oprot.writeFieldEnd()
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
3431 rajveer 11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
1976 varun.gupt 11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
11951 
class removeCoupon_args:
11952 
  """
11953 
  Attributes:
11954 
   - cartId
11955 
  """
11956 
 
11957 
  thrift_spec = (
11958 
    None, # 0
11959 
    (1, TType.I64, 'cartId', None, None, ), # 1
11960 
  )
11961 
 
11962 
  def __init__(self, cartId=None,):
11963 
    self.cartId = cartId
11964 
 
11965 
  def read(self, iprot):
11966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11968 
      return
11969 
    iprot.readStructBegin()
11970 
    while True:
11971 
      (fname, ftype, fid) = iprot.readFieldBegin()
11972 
      if ftype == TType.STOP:
11973 
        break
11974 
      if fid == 1:
11975 
        if ftype == TType.I64:
11976 
          self.cartId = iprot.readI64();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      else:
11980 
        iprot.skip(ftype)
11981 
      iprot.readFieldEnd()
11982 
    iprot.readStructEnd()
11983 
 
11984 
  def write(self, oprot):
11985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11987 
      return
11988 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11989 
    if self.cartId is not None:
1976 varun.gupt 11990 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11991 
      oprot.writeI64(self.cartId)
11992 
      oprot.writeFieldEnd()
11993 
    oprot.writeFieldStop()
11994 
    oprot.writeStructEnd()
11995 
 
3431 rajveer 11996 
  def validate(self):
11997 
    return
11998 
 
11999 
 
1976 varun.gupt 12000 
  def __repr__(self):
12001 
    L = ['%s=%r' % (key, value)
12002 
      for key, value in self.__dict__.iteritems()]
12003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12004 
 
12005 
  def __eq__(self, other):
12006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12007 
 
12008 
  def __ne__(self, other):
12009 
    return not (self == other)
12010 
 
12011 
class removeCoupon_result:
12012 
  """
12013 
  Attributes:
12014 
   - scx
12015 
  """
12016 
 
12017 
  thrift_spec = (
12018 
    None, # 0
12019 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12020 
  )
12021 
 
12022 
  def __init__(self, scx=None,):
12023 
    self.scx = scx
12024 
 
12025 
  def read(self, iprot):
12026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12028 
      return
12029 
    iprot.readStructBegin()
12030 
    while True:
12031 
      (fname, ftype, fid) = iprot.readFieldBegin()
12032 
      if ftype == TType.STOP:
12033 
        break
12034 
      if fid == 1:
12035 
        if ftype == TType.STRUCT:
12036 
          self.scx = ShoppingCartException()
12037 
          self.scx.read(iprot)
12038 
        else:
12039 
          iprot.skip(ftype)
12040 
      else:
12041 
        iprot.skip(ftype)
12042 
      iprot.readFieldEnd()
12043 
    iprot.readStructEnd()
12044 
 
12045 
  def write(self, oprot):
12046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12048 
      return
12049 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 12050 
    if self.scx is not None:
1976 varun.gupt 12051 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12052 
      self.scx.write(oprot)
12053 
      oprot.writeFieldEnd()
12054 
    oprot.writeFieldStop()
12055 
    oprot.writeStructEnd()
12056 
 
3431 rajveer 12057 
  def validate(self):
12058 
    return
12059 
 
12060 
 
1976 varun.gupt 12061 
  def __repr__(self):
12062 
    L = ['%s=%r' % (key, value)
12063 
      for key, value in self.__dict__.iteritems()]
12064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12065 
 
12066 
  def __eq__(self, other):
12067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12068 
 
12069 
  def __ne__(self, other):
12070 
    return not (self == other)
12071 
 
3554 varun.gupt 12072 
class deleteDiscountsFromCart_args:
12073 
  """
12074 
  Attributes:
12075 
   - cartId
12076 
  """
12077 
 
12078 
  thrift_spec = (
12079 
    None, # 0
12080 
    (1, TType.I64, 'cartId', None, None, ), # 1
12081 
  )
12082 
 
12083 
  def __init__(self, cartId=None,):
12084 
    self.cartId = cartId
12085 
 
12086 
  def read(self, iprot):
12087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12089 
      return
12090 
    iprot.readStructBegin()
12091 
    while True:
12092 
      (fname, ftype, fid) = iprot.readFieldBegin()
12093 
      if ftype == TType.STOP:
12094 
        break
12095 
      if fid == 1:
12096 
        if ftype == TType.I64:
12097 
          self.cartId = iprot.readI64();
12098 
        else:
12099 
          iprot.skip(ftype)
12100 
      else:
12101 
        iprot.skip(ftype)
12102 
      iprot.readFieldEnd()
12103 
    iprot.readStructEnd()
12104 
 
12105 
  def write(self, oprot):
12106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12108 
      return
12109 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12110 
    if self.cartId is not None:
12111 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12112 
      oprot.writeI64(self.cartId)
12113 
      oprot.writeFieldEnd()
12114 
    oprot.writeFieldStop()
12115 
    oprot.writeStructEnd()
12116 
 
12117 
  def validate(self):
12118 
    return
12119 
 
12120 
 
12121 
  def __repr__(self):
12122 
    L = ['%s=%r' % (key, value)
12123 
      for key, value in self.__dict__.iteritems()]
12124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12125 
 
12126 
  def __eq__(self, other):
12127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12128 
 
12129 
  def __ne__(self, other):
12130 
    return not (self == other)
12131 
 
12132 
class deleteDiscountsFromCart_result:
12133 
  """
12134 
  Attributes:
12135 
   - scx
12136 
  """
12137 
 
12138 
  thrift_spec = (
12139 
    None, # 0
12140 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12141 
  )
12142 
 
12143 
  def __init__(self, scx=None,):
12144 
    self.scx = scx
12145 
 
12146 
  def read(self, iprot):
12147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12149 
      return
12150 
    iprot.readStructBegin()
12151 
    while True:
12152 
      (fname, ftype, fid) = iprot.readFieldBegin()
12153 
      if ftype == TType.STOP:
12154 
        break
12155 
      if fid == 1:
12156 
        if ftype == TType.STRUCT:
12157 
          self.scx = ShoppingCartException()
12158 
          self.scx.read(iprot)
12159 
        else:
12160 
          iprot.skip(ftype)
12161 
      else:
12162 
        iprot.skip(ftype)
12163 
      iprot.readFieldEnd()
12164 
    iprot.readStructEnd()
12165 
 
12166 
  def write(self, oprot):
12167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12169 
      return
12170 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12171 
    if self.scx is not None:
12172 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12173 
      self.scx.write(oprot)
12174 
      oprot.writeFieldEnd()
12175 
    oprot.writeFieldStop()
12176 
    oprot.writeStructEnd()
12177 
 
12178 
  def validate(self):
12179 
    return
12180 
 
12181 
 
12182 
  def __repr__(self):
12183 
    L = ['%s=%r' % (key, value)
12184 
      for key, value in self.__dict__.iteritems()]
12185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12186 
 
12187 
  def __eq__(self, other):
12188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12189 
 
12190 
  def __ne__(self, other):
12191 
    return not (self == other)
12192 
 
12193 
class saveDiscounts_args:
12194 
  """
12195 
  Attributes:
12196 
   - discounts
12197 
  """
12198 
 
12199 
  thrift_spec = (
12200 
    None, # 0
12201 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12202 
  )
12203 
 
12204 
  def __init__(self, discounts=None,):
12205 
    self.discounts = discounts
12206 
 
12207 
  def read(self, iprot):
12208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12210 
      return
12211 
    iprot.readStructBegin()
12212 
    while True:
12213 
      (fname, ftype, fid) = iprot.readFieldBegin()
12214 
      if ftype == TType.STOP:
12215 
        break
12216 
      if fid == 1:
12217 
        if ftype == TType.LIST:
12218 
          self.discounts = []
11592 amit.gupta 12219 
          (_etype163, _size160) = iprot.readListBegin()
12220 
          for _i164 in xrange(_size160):
12221 
            _elem165 = Discount()
12222 
            _elem165.read(iprot)
12223 
            self.discounts.append(_elem165)
3554 varun.gupt 12224 
          iprot.readListEnd()
12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      else:
12228 
        iprot.skip(ftype)
12229 
      iprot.readFieldEnd()
12230 
    iprot.readStructEnd()
12231 
 
12232 
  def write(self, oprot):
12233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12235 
      return
12236 
    oprot.writeStructBegin('saveDiscounts_args')
12237 
    if self.discounts is not None:
12238 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12239 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12240 
      for iter166 in self.discounts:
12241 
        iter166.write(oprot)
3554 varun.gupt 12242 
      oprot.writeListEnd()
12243 
      oprot.writeFieldEnd()
12244 
    oprot.writeFieldStop()
12245 
    oprot.writeStructEnd()
12246 
 
12247 
  def validate(self):
12248 
    return
12249 
 
12250 
 
12251 
  def __repr__(self):
12252 
    L = ['%s=%r' % (key, value)
12253 
      for key, value in self.__dict__.iteritems()]
12254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12255 
 
12256 
  def __eq__(self, other):
12257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12258 
 
12259 
  def __ne__(self, other):
12260 
    return not (self == other)
12261 
 
12262 
class saveDiscounts_result:
12263 
  """
12264 
  Attributes:
12265 
   - scx
12266 
  """
12267 
 
12268 
  thrift_spec = (
12269 
    None, # 0
12270 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12271 
  )
12272 
 
12273 
  def __init__(self, scx=None,):
12274 
    self.scx = scx
12275 
 
12276 
  def read(self, iprot):
12277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12279 
      return
12280 
    iprot.readStructBegin()
12281 
    while True:
12282 
      (fname, ftype, fid) = iprot.readFieldBegin()
12283 
      if ftype == TType.STOP:
12284 
        break
12285 
      if fid == 1:
12286 
        if ftype == TType.STRUCT:
12287 
          self.scx = ShoppingCartException()
12288 
          self.scx.read(iprot)
12289 
        else:
12290 
          iprot.skip(ftype)
12291 
      else:
12292 
        iprot.skip(ftype)
12293 
      iprot.readFieldEnd()
12294 
    iprot.readStructEnd()
12295 
 
12296 
  def write(self, oprot):
12297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12299 
      return
12300 
    oprot.writeStructBegin('saveDiscounts_result')
12301 
    if self.scx is not None:
12302 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12303 
      self.scx.write(oprot)
12304 
      oprot.writeFieldEnd()
12305 
    oprot.writeFieldStop()
12306 
    oprot.writeStructEnd()
12307 
 
12308 
  def validate(self):
12309 
    return
12310 
 
12311 
 
12312 
  def __repr__(self):
12313 
    L = ['%s=%r' % (key, value)
12314 
      for key, value in self.__dict__.iteritems()]
12315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12316 
 
12317 
  def __eq__(self, other):
12318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12319 
 
12320 
  def __ne__(self, other):
12321 
    return not (self == other)
12322 
 
690 chandransh 12323 
class createOrders_args:
559 chandransh 12324 
  """
12325 
  Attributes:
12326 
   - cartId
2815 vikas 12327 
   - sessionSource
12328 
   - sessionStartTime
3858 vikas 12329 
   - firstSource
12330 
   - firstSourceTime
5326 rajveer 12331 
   - userId
6389 rajveer 12332 
   - schemeId
11526 amit.gupta 12333 
   - orderSource
559 chandransh 12334 
  """
12335 
 
12336 
  thrift_spec = (
12337 
    None, # 0
12338 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12339 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12340 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12341 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12342 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12343 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12344 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12345 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12346 
  )
12347 
 
11526 amit.gupta 12348 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12349 
    self.cartId = cartId
2815 vikas 12350 
    self.sessionSource = sessionSource
12351 
    self.sessionStartTime = sessionStartTime
3858 vikas 12352 
    self.firstSource = firstSource
12353 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12354 
    self.userId = userId
6389 rajveer 12355 
    self.schemeId = schemeId
11526 amit.gupta 12356 
    self.orderSource = orderSource
559 chandransh 12357 
 
12358 
  def read(self, iprot):
12359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12361 
      return
12362 
    iprot.readStructBegin()
12363 
    while True:
12364 
      (fname, ftype, fid) = iprot.readFieldBegin()
12365 
      if ftype == TType.STOP:
12366 
        break
12367 
      if fid == 1:
12368 
        if ftype == TType.I64:
12369 
          self.cartId = iprot.readI64();
12370 
        else:
12371 
          iprot.skip(ftype)
2815 vikas 12372 
      elif fid == 2:
12373 
        if ftype == TType.STRING:
12374 
          self.sessionSource = iprot.readString();
12375 
        else:
12376 
          iprot.skip(ftype)
12377 
      elif fid == 3:
12378 
        if ftype == TType.I64:
12379 
          self.sessionStartTime = iprot.readI64();
12380 
        else:
12381 
          iprot.skip(ftype)
3858 vikas 12382 
      elif fid == 4:
12383 
        if ftype == TType.STRING:
12384 
          self.firstSource = iprot.readString();
12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      elif fid == 5:
12388 
        if ftype == TType.I64:
12389 
          self.firstSourceTime = iprot.readI64();
12390 
        else:
12391 
          iprot.skip(ftype)
5326 rajveer 12392 
      elif fid == 6:
12393 
        if ftype == TType.I64:
12394 
          self.userId = iprot.readI64();
12395 
        else:
12396 
          iprot.skip(ftype)
6389 rajveer 12397 
      elif fid == 7:
12398 
        if ftype == TType.I64:
12399 
          self.schemeId = iprot.readI64();
12400 
        else:
12401 
          iprot.skip(ftype)
11526 amit.gupta 12402 
      elif fid == 8:
12403 
        if ftype == TType.I64:
12404 
          self.orderSource = iprot.readI64();
12405 
        else:
12406 
          iprot.skip(ftype)
559 chandransh 12407 
      else:
12408 
        iprot.skip(ftype)
12409 
      iprot.readFieldEnd()
12410 
    iprot.readStructEnd()
12411 
 
12412 
  def write(self, oprot):
12413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12415 
      return
690 chandransh 12416 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12417 
    if self.cartId is not None:
559 chandransh 12418 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12419 
      oprot.writeI64(self.cartId)
12420 
      oprot.writeFieldEnd()
3431 rajveer 12421 
    if self.sessionSource is not None:
2815 vikas 12422 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12423 
      oprot.writeString(self.sessionSource)
12424 
      oprot.writeFieldEnd()
3431 rajveer 12425 
    if self.sessionStartTime is not None:
2815 vikas 12426 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12427 
      oprot.writeI64(self.sessionStartTime)
12428 
      oprot.writeFieldEnd()
3858 vikas 12429 
    if self.firstSource is not None:
12430 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12431 
      oprot.writeString(self.firstSource)
12432 
      oprot.writeFieldEnd()
12433 
    if self.firstSourceTime is not None:
12434 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12435 
      oprot.writeI64(self.firstSourceTime)
12436 
      oprot.writeFieldEnd()
5326 rajveer 12437 
    if self.userId is not None:
12438 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12439 
      oprot.writeI64(self.userId)
12440 
      oprot.writeFieldEnd()
6389 rajveer 12441 
    if self.schemeId is not None:
12442 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12443 
      oprot.writeI64(self.schemeId)
12444 
      oprot.writeFieldEnd()
11526 amit.gupta 12445 
    if self.orderSource is not None:
12446 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12447 
      oprot.writeI64(self.orderSource)
12448 
      oprot.writeFieldEnd()
559 chandransh 12449 
    oprot.writeFieldStop()
12450 
    oprot.writeStructEnd()
12451 
 
3431 rajveer 12452 
  def validate(self):
12453 
    return
12454 
 
12455 
 
559 chandransh 12456 
  def __repr__(self):
12457 
    L = ['%s=%r' % (key, value)
12458 
      for key, value in self.__dict__.iteritems()]
12459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12460 
 
12461 
  def __eq__(self, other):
12462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12463 
 
12464 
  def __ne__(self, other):
12465 
    return not (self == other)
12466 
 
690 chandransh 12467 
class createOrders_result:
559 chandransh 12468 
  """
12469 
  Attributes:
94 ashish 12470 
   - success
559 chandransh 12471 
   - scx
94 ashish 12472 
  """
12473 
 
12474 
  thrift_spec = (
575 chandransh 12475 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12476 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12477 
  )
12478 
 
559 chandransh 12479 
  def __init__(self, success=None, scx=None,):
94 ashish 12480 
    self.success = success
559 chandransh 12481 
    self.scx = scx
94 ashish 12482 
 
12483 
  def read(self, iprot):
12484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12486 
      return
12487 
    iprot.readStructBegin()
12488 
    while True:
12489 
      (fname, ftype, fid) = iprot.readFieldBegin()
12490 
      if ftype == TType.STOP:
12491 
        break
12492 
      if fid == 0:
575 chandransh 12493 
        if ftype == TType.I64:
12494 
          self.success = iprot.readI64();
94 ashish 12495 
        else:
12496 
          iprot.skip(ftype)
12497 
      elif fid == 1:
12498 
        if ftype == TType.STRUCT:
559 chandransh 12499 
          self.scx = ShoppingCartException()
12500 
          self.scx.read(iprot)
94 ashish 12501 
        else:
12502 
          iprot.skip(ftype)
12503 
      else:
12504 
        iprot.skip(ftype)
12505 
      iprot.readFieldEnd()
12506 
    iprot.readStructEnd()
12507 
 
12508 
  def write(self, oprot):
12509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12511 
      return
690 chandransh 12512 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12513 
    if self.success is not None:
575 chandransh 12514 
      oprot.writeFieldBegin('success', TType.I64, 0)
12515 
      oprot.writeI64(self.success)
94 ashish 12516 
      oprot.writeFieldEnd()
3431 rajveer 12517 
    if self.scx is not None:
559 chandransh 12518 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12519 
      self.scx.write(oprot)
94 ashish 12520 
      oprot.writeFieldEnd()
12521 
    oprot.writeFieldStop()
12522 
    oprot.writeStructEnd()
12523 
 
3431 rajveer 12524 
  def validate(self):
12525 
    return
12526 
 
12527 
 
94 ashish 12528 
  def __repr__(self):
12529 
    L = ['%s=%r' % (key, value)
12530 
      for key, value in self.__dict__.iteritems()]
12531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12532 
 
12533 
  def __eq__(self, other):
12534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12535 
 
12536 
  def __ne__(self, other):
12537 
    return not (self == other)
12538 
 
559 chandransh 12539 
class validateCart_args:
94 ashish 12540 
  """
12541 
  Attributes:
559 chandransh 12542 
   - cartId
3557 rajveer 12543 
   - sourceId
94 ashish 12544 
  """
12545 
 
12546 
  thrift_spec = (
12547 
    None, # 0
559 chandransh 12548 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12549 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12550 
  )
12551 
 
3557 rajveer 12552 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12553 
    self.cartId = cartId
3557 rajveer 12554 
    self.sourceId = sourceId
94 ashish 12555 
 
12556 
  def read(self, iprot):
12557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12559 
      return
12560 
    iprot.readStructBegin()
12561 
    while True:
12562 
      (fname, ftype, fid) = iprot.readFieldBegin()
12563 
      if ftype == TType.STOP:
12564 
        break
12565 
      if fid == 1:
12566 
        if ftype == TType.I64:
559 chandransh 12567 
          self.cartId = iprot.readI64();
94 ashish 12568 
        else:
12569 
          iprot.skip(ftype)
3557 rajveer 12570 
      elif fid == 2:
12571 
        if ftype == TType.I64:
12572 
          self.sourceId = iprot.readI64();
12573 
        else:
12574 
          iprot.skip(ftype)
94 ashish 12575 
      else:
12576 
        iprot.skip(ftype)
12577 
      iprot.readFieldEnd()
12578 
    iprot.readStructEnd()
12579 
 
12580 
  def write(self, oprot):
12581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12583 
      return
559 chandransh 12584 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12585 
    if self.cartId is not None:
559 chandransh 12586 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12587 
      oprot.writeI64(self.cartId)
94 ashish 12588 
      oprot.writeFieldEnd()
3557 rajveer 12589 
    if self.sourceId is not None:
12590 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12591 
      oprot.writeI64(self.sourceId)
12592 
      oprot.writeFieldEnd()
94 ashish 12593 
    oprot.writeFieldStop()
12594 
    oprot.writeStructEnd()
12595 
 
3431 rajveer 12596 
  def validate(self):
12597 
    return
12598 
 
12599 
 
94 ashish 12600 
  def __repr__(self):
12601 
    L = ['%s=%r' % (key, value)
12602 
      for key, value in self.__dict__.iteritems()]
12603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12604 
 
12605 
  def __eq__(self, other):
12606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12607 
 
12608 
  def __ne__(self, other):
12609 
    return not (self == other)
12610 
 
559 chandransh 12611 
class validateCart_result:
94 ashish 12612 
  """
12613 
  Attributes:
12614 
   - success
575 chandransh 12615 
   - scex
94 ashish 12616 
  """
12617 
 
12618 
  thrift_spec = (
6736 amit.gupta 12619 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12620 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12621 
  )
12622 
 
575 chandransh 12623 
  def __init__(self, success=None, scex=None,):
94 ashish 12624 
    self.success = success
575 chandransh 12625 
    self.scex = scex
94 ashish 12626 
 
12627 
  def read(self, iprot):
12628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12630 
      return
12631 
    iprot.readStructBegin()
12632 
    while True:
12633 
      (fname, ftype, fid) = iprot.readFieldBegin()
12634 
      if ftype == TType.STOP:
12635 
        break
12636 
      if fid == 0:
6736 amit.gupta 12637 
        if ftype == TType.LIST:
12638 
          self.success = []
11592 amit.gupta 12639 
          (_etype170, _size167) = iprot.readListBegin()
12640 
          for _i171 in xrange(_size167):
12641 
            _elem172 = iprot.readString();
12642 
            self.success.append(_elem172)
6736 amit.gupta 12643 
          iprot.readListEnd()
94 ashish 12644 
        else:
12645 
          iprot.skip(ftype)
575 chandransh 12646 
      elif fid == 1:
12647 
        if ftype == TType.STRUCT:
12648 
          self.scex = ShoppingCartException()
12649 
          self.scex.read(iprot)
12650 
        else:
12651 
          iprot.skip(ftype)
94 ashish 12652 
      else:
12653 
        iprot.skip(ftype)
12654 
      iprot.readFieldEnd()
12655 
    iprot.readStructEnd()
12656 
 
12657 
  def write(self, oprot):
12658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12660 
      return
559 chandransh 12661 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12662 
    if self.success is not None:
6736 amit.gupta 12663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12664 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12665 
      for iter173 in self.success:
12666 
        oprot.writeString(iter173)
6736 amit.gupta 12667 
      oprot.writeListEnd()
94 ashish 12668 
      oprot.writeFieldEnd()
3431 rajveer 12669 
    if self.scex is not None:
575 chandransh 12670 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12671 
      self.scex.write(oprot)
12672 
      oprot.writeFieldEnd()
559 chandransh 12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
3431 rajveer 12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
559 chandransh 12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
12690 
 
11980 amit.gupta 12691 
class validateCartWithDealerCoupon_args:
12692 
  """
12693 
  Attributes:
12694 
   - cartId
12695 
   - sourceId
12696 
   - dealCoupon
12697 
  """
12698 
 
12699 
  thrift_spec = (
12700 
    None, # 0
12701 
    (1, TType.I64, 'cartId', None, None, ), # 1
12702 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12703 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12704 
  )
12705 
 
12706 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12707 
    self.cartId = cartId
12708 
    self.sourceId = sourceId
12709 
    self.dealCoupon = dealCoupon
12710 
 
12711 
  def read(self, iprot):
12712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12714 
      return
12715 
    iprot.readStructBegin()
12716 
    while True:
12717 
      (fname, ftype, fid) = iprot.readFieldBegin()
12718 
      if ftype == TType.STOP:
12719 
        break
12720 
      if fid == 1:
12721 
        if ftype == TType.I64:
12722 
          self.cartId = iprot.readI64();
12723 
        else:
12724 
          iprot.skip(ftype)
12725 
      elif fid == 2:
12726 
        if ftype == TType.I64:
12727 
          self.sourceId = iprot.readI64();
12728 
        else:
12729 
          iprot.skip(ftype)
12730 
      elif fid == 3:
12731 
        if ftype == TType.STRING:
12732 
          self.dealCoupon = iprot.readString();
12733 
        else:
12734 
          iprot.skip(ftype)
12735 
      else:
12736 
        iprot.skip(ftype)
12737 
      iprot.readFieldEnd()
12738 
    iprot.readStructEnd()
12739 
 
12740 
  def write(self, oprot):
12741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12743 
      return
12744 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12745 
    if self.cartId is not None:
12746 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12747 
      oprot.writeI64(self.cartId)
12748 
      oprot.writeFieldEnd()
12749 
    if self.sourceId is not None:
12750 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12751 
      oprot.writeI64(self.sourceId)
12752 
      oprot.writeFieldEnd()
12753 
    if self.dealCoupon is not None:
12754 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12755 
      oprot.writeString(self.dealCoupon)
12756 
      oprot.writeFieldEnd()
12757 
    oprot.writeFieldStop()
12758 
    oprot.writeStructEnd()
12759 
 
12760 
  def validate(self):
12761 
    return
12762 
 
12763 
 
12764 
  def __repr__(self):
12765 
    L = ['%s=%r' % (key, value)
12766 
      for key, value in self.__dict__.iteritems()]
12767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12768 
 
12769 
  def __eq__(self, other):
12770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12771 
 
12772 
  def __ne__(self, other):
12773 
    return not (self == other)
12774 
 
12775 
class validateCartWithDealerCoupon_result:
12776 
  """
12777 
  Attributes:
12778 
   - success
12779 
   - scex
12780 
  """
12781 
 
12782 
  thrift_spec = (
12783 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12784 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12785 
  )
12786 
 
12787 
  def __init__(self, success=None, scex=None,):
12788 
    self.success = success
12789 
    self.scex = scex
12790 
 
12791 
  def read(self, iprot):
12792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12794 
      return
12795 
    iprot.readStructBegin()
12796 
    while True:
12797 
      (fname, ftype, fid) = iprot.readFieldBegin()
12798 
      if ftype == TType.STOP:
12799 
        break
12800 
      if fid == 0:
12801 
        if ftype == TType.LIST:
12802 
          self.success = []
12803 
          (_etype177, _size174) = iprot.readListBegin()
12804 
          for _i178 in xrange(_size174):
12805 
            _elem179 = iprot.readString();
12806 
            self.success.append(_elem179)
12807 
          iprot.readListEnd()
12808 
        else:
12809 
          iprot.skip(ftype)
12810 
      elif fid == 1:
12811 
        if ftype == TType.STRUCT:
12812 
          self.scex = ShoppingCartException()
12813 
          self.scex.read(iprot)
12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      else:
12817 
        iprot.skip(ftype)
12818 
      iprot.readFieldEnd()
12819 
    iprot.readStructEnd()
12820 
 
12821 
  def write(self, oprot):
12822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12824 
      return
12825 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12826 
    if self.success is not None:
12827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12828 
      oprot.writeListBegin(TType.STRING, len(self.success))
12829 
      for iter180 in self.success:
12830 
        oprot.writeString(iter180)
12831 
      oprot.writeListEnd()
12832 
      oprot.writeFieldEnd()
12833 
    if self.scex is not None:
12834 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12835 
      self.scex.write(oprot)
12836 
      oprot.writeFieldEnd()
12837 
    oprot.writeFieldStop()
12838 
    oprot.writeStructEnd()
12839 
 
12840 
  def validate(self):
12841 
    return
12842 
 
12843 
 
12844 
  def __repr__(self):
12845 
    L = ['%s=%r' % (key, value)
12846 
      for key, value in self.__dict__.iteritems()]
12847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12848 
 
12849 
  def __eq__(self, other):
12850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12851 
 
12852 
  def __ne__(self, other):
12853 
    return not (self == other)
12854 
 
690 chandransh 12855 
class mergeCart_args:
575 chandransh 12856 
  """
12857 
  Attributes:
690 chandransh 12858 
   - fromCartId
12859 
   - toCartId
12860 
  """
12861 
 
12862 
  thrift_spec = (
12863 
    None, # 0
12864 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12865 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12866 
  )
12867 
 
12868 
  def __init__(self, fromCartId=None, toCartId=None,):
12869 
    self.fromCartId = fromCartId
12870 
    self.toCartId = toCartId
12871 
 
12872 
  def read(self, iprot):
12873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12875 
      return
12876 
    iprot.readStructBegin()
12877 
    while True:
12878 
      (fname, ftype, fid) = iprot.readFieldBegin()
12879 
      if ftype == TType.STOP:
12880 
        break
12881 
      if fid == 1:
12882 
        if ftype == TType.I64:
12883 
          self.fromCartId = iprot.readI64();
12884 
        else:
12885 
          iprot.skip(ftype)
12886 
      elif fid == 2:
12887 
        if ftype == TType.I64:
12888 
          self.toCartId = iprot.readI64();
12889 
        else:
12890 
          iprot.skip(ftype)
12891 
      else:
12892 
        iprot.skip(ftype)
12893 
      iprot.readFieldEnd()
12894 
    iprot.readStructEnd()
12895 
 
12896 
  def write(self, oprot):
12897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12899 
      return
12900 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12901 
    if self.fromCartId is not None:
690 chandransh 12902 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12903 
      oprot.writeI64(self.fromCartId)
12904 
      oprot.writeFieldEnd()
3431 rajveer 12905 
    if self.toCartId is not None:
690 chandransh 12906 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12907 
      oprot.writeI64(self.toCartId)
12908 
      oprot.writeFieldEnd()
12909 
    oprot.writeFieldStop()
12910 
    oprot.writeStructEnd()
12911 
 
3431 rajveer 12912 
  def validate(self):
12913 
    return
12914 
 
12915 
 
690 chandransh 12916 
  def __repr__(self):
12917 
    L = ['%s=%r' % (key, value)
12918 
      for key, value in self.__dict__.iteritems()]
12919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12920 
 
12921 
  def __eq__(self, other):
12922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12923 
 
12924 
  def __ne__(self, other):
12925 
    return not (self == other)
12926 
 
12927 
class mergeCart_result:
12928 
 
12929 
  thrift_spec = (
12930 
  )
12931 
 
12932 
  def read(self, iprot):
12933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12935 
      return
12936 
    iprot.readStructBegin()
12937 
    while True:
12938 
      (fname, ftype, fid) = iprot.readFieldBegin()
12939 
      if ftype == TType.STOP:
12940 
        break
12941 
      else:
12942 
        iprot.skip(ftype)
12943 
      iprot.readFieldEnd()
12944 
    iprot.readStructEnd()
12945 
 
12946 
  def write(self, oprot):
12947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12949 
      return
12950 
    oprot.writeStructBegin('mergeCart_result')
12951 
    oprot.writeFieldStop()
12952 
    oprot.writeStructEnd()
12953 
 
3431 rajveer 12954 
  def validate(self):
12955 
    return
12956 
 
12957 
 
690 chandransh 12958 
  def __repr__(self):
12959 
    L = ['%s=%r' % (key, value)
12960 
      for key, value in self.__dict__.iteritems()]
12961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12962 
 
12963 
  def __eq__(self, other):
12964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12965 
 
12966 
  def __ne__(self, other):
12967 
    return not (self == other)
12968 
 
12969 
class checkOut_args:
12970 
  """
12971 
  Attributes:
575 chandransh 12972 
   - cartId
12973 
  """
12974 
 
12975 
  thrift_spec = (
12976 
    None, # 0
12977 
    (1, TType.I64, 'cartId', None, None, ), # 1
12978 
  )
12979 
 
12980 
  def __init__(self, cartId=None,):
12981 
    self.cartId = cartId
12982 
 
12983 
  def read(self, iprot):
12984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12986 
      return
12987 
    iprot.readStructBegin()
12988 
    while True:
12989 
      (fname, ftype, fid) = iprot.readFieldBegin()
12990 
      if ftype == TType.STOP:
12991 
        break
12992 
      if fid == 1:
12993 
        if ftype == TType.I64:
12994 
          self.cartId = iprot.readI64();
12995 
        else:
12996 
          iprot.skip(ftype)
12997 
      else:
12998 
        iprot.skip(ftype)
12999 
      iprot.readFieldEnd()
13000 
    iprot.readStructEnd()
13001 
 
13002 
  def write(self, oprot):
13003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13005 
      return
690 chandransh 13006 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 13007 
    if self.cartId is not None:
575 chandransh 13008 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13009 
      oprot.writeI64(self.cartId)
13010 
      oprot.writeFieldEnd()
13011 
    oprot.writeFieldStop()
13012 
    oprot.writeStructEnd()
13013 
 
3431 rajveer 13014 
  def validate(self):
13015 
    return
13016 
 
13017 
 
575 chandransh 13018 
  def __repr__(self):
13019 
    L = ['%s=%r' % (key, value)
13020 
      for key, value in self.__dict__.iteritems()]
13021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13022 
 
13023 
  def __eq__(self, other):
13024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13025 
 
13026 
  def __ne__(self, other):
13027 
    return not (self == other)
13028 
 
690 chandransh 13029 
class checkOut_result:
575 chandransh 13030 
  """
13031 
  Attributes:
13032 
   - success
13033 
   - scex
13034 
  """
13035 
 
13036 
  thrift_spec = (
13037 
    (0, TType.BOOL, 'success', None, None, ), # 0
13038 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
13039 
  )
13040 
 
13041 
  def __init__(self, success=None, scex=None,):
13042 
    self.success = success
13043 
    self.scex = scex
13044 
 
13045 
  def read(self, iprot):
13046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13048 
      return
13049 
    iprot.readStructBegin()
13050 
    while True:
13051 
      (fname, ftype, fid) = iprot.readFieldBegin()
13052 
      if ftype == TType.STOP:
13053 
        break
13054 
      if fid == 0:
13055 
        if ftype == TType.BOOL:
13056 
          self.success = iprot.readBool();
13057 
        else:
13058 
          iprot.skip(ftype)
13059 
      elif fid == 1:
13060 
        if ftype == TType.STRUCT:
13061 
          self.scex = ShoppingCartException()
13062 
          self.scex.read(iprot)
13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      else:
13066 
        iprot.skip(ftype)
13067 
      iprot.readFieldEnd()
13068 
    iprot.readStructEnd()
13069 
 
13070 
  def write(self, oprot):
13071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13073 
      return
690 chandransh 13074 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 13075 
    if self.success is not None:
575 chandransh 13076 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13077 
      oprot.writeBool(self.success)
13078 
      oprot.writeFieldEnd()
3431 rajveer 13079 
    if self.scex is not None:
575 chandransh 13080 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13081 
      self.scex.write(oprot)
13082 
      oprot.writeFieldEnd()
13083 
    oprot.writeFieldStop()
13084 
    oprot.writeStructEnd()
13085 
 
3431 rajveer 13086 
  def validate(self):
13087 
    return
13088 
 
13089 
 
575 chandransh 13090 
  def __repr__(self):
13091 
    L = ['%s=%r' % (key, value)
13092 
      for key, value in self.__dict__.iteritems()]
13093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13094 
 
13095 
  def __eq__(self, other):
13096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13097 
 
13098 
  def __ne__(self, other):
13099 
    return not (self == other)
13100 
 
690 chandransh 13101 
class resetCart_args:
559 chandransh 13102 
  """
13103 
  Attributes:
690 chandransh 13104 
   - cartId
13105 
   - items
559 chandransh 13106 
  """
13107 
 
13108 
  thrift_spec = (
13109 
    None, # 0
690 chandransh 13110 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13111 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13112 
  )
13113 
 
690 chandransh 13114 
  def __init__(self, cartId=None, items=None,):
13115 
    self.cartId = cartId
13116 
    self.items = items
559 chandransh 13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 1:
13128 
        if ftype == TType.I64:
690 chandransh 13129 
          self.cartId = iprot.readI64();
559 chandransh 13130 
        else:
13131 
          iprot.skip(ftype)
13132 
      elif fid == 2:
690 chandransh 13133 
        if ftype == TType.MAP:
13134 
          self.items = {}
11980 amit.gupta 13135 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13136 
          for _i185 in xrange(_size181):
13137 
            _key186 = iprot.readI64();
13138 
            _val187 = iprot.readDouble();
13139 
            self.items[_key186] = _val187
690 chandransh 13140 
          iprot.readMapEnd()
559 chandransh 13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
690 chandransh 13152 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13153 
    if self.cartId is not None:
690 chandransh 13154 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13155 
      oprot.writeI64(self.cartId)
94 ashish 13156 
      oprot.writeFieldEnd()
3431 rajveer 13157 
    if self.items is not None:
690 chandransh 13158 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13159 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13160 
      for kiter188,viter189 in self.items.items():
13161 
        oprot.writeI64(kiter188)
13162 
        oprot.writeDouble(viter189)
690 chandransh 13163 
      oprot.writeMapEnd()
559 chandransh 13164 
      oprot.writeFieldEnd()
94 ashish 13165 
    oprot.writeFieldStop()
13166 
    oprot.writeStructEnd()
13167 
 
3431 rajveer 13168 
  def validate(self):
13169 
    return
13170 
 
13171 
 
94 ashish 13172 
  def __repr__(self):
13173 
    L = ['%s=%r' % (key, value)
13174 
      for key, value in self.__dict__.iteritems()]
13175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13176 
 
13177 
  def __eq__(self, other):
13178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13179 
 
13180 
  def __ne__(self, other):
13181 
    return not (self == other)
13182 
 
690 chandransh 13183 
class resetCart_result:
13184 
  """
13185 
  Attributes:
13186 
   - success
13187 
   - scex
13188 
  """
559 chandransh 13189 
 
13190 
  thrift_spec = (
690 chandransh 13191 
    (0, TType.BOOL, 'success', None, None, ), # 0
13192 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13193 
  )
13194 
 
690 chandransh 13195 
  def __init__(self, success=None, scex=None,):
13196 
    self.success = success
13197 
    self.scex = scex
13198 
 
559 chandransh 13199 
  def read(self, iprot):
13200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13202 
      return
13203 
    iprot.readStructBegin()
13204 
    while True:
13205 
      (fname, ftype, fid) = iprot.readFieldBegin()
13206 
      if ftype == TType.STOP:
13207 
        break
690 chandransh 13208 
      if fid == 0:
13209 
        if ftype == TType.BOOL:
13210 
          self.success = iprot.readBool();
13211 
        else:
13212 
          iprot.skip(ftype)
13213 
      elif fid == 1:
13214 
        if ftype == TType.STRUCT:
13215 
          self.scex = ShoppingCartException()
13216 
          self.scex.read(iprot)
13217 
        else:
13218 
          iprot.skip(ftype)
559 chandransh 13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
690 chandransh 13228 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13229 
    if self.success is not None:
690 chandransh 13230 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13231 
      oprot.writeBool(self.success)
13232 
      oprot.writeFieldEnd()
3431 rajveer 13233 
    if self.scex is not None:
690 chandransh 13234 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13235 
      self.scex.write(oprot)
13236 
      oprot.writeFieldEnd()
559 chandransh 13237 
    oprot.writeFieldStop()
13238 
    oprot.writeStructEnd()
13239 
 
3431 rajveer 13240 
  def validate(self):
13241 
    return
13242 
 
13243 
 
559 chandransh 13244 
  def __repr__(self):
13245 
    L = ['%s=%r' % (key, value)
13246 
      for key, value in self.__dict__.iteritems()]
13247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13248 
 
13249 
  def __eq__(self, other):
13250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13251 
 
13252 
  def __ne__(self, other):
13253 
    return not (self == other)
13254 
 
2981 rajveer 13255 
class getUserCount_args:
94 ashish 13256 
  """
13257 
  Attributes:
2981 rajveer 13258 
   - userType
559 chandransh 13259 
  """
13260 
 
13261 
  thrift_spec = (
13262 
    None, # 0
2981 rajveer 13263 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13264 
  )
13265 
 
2981 rajveer 13266 
  def __init__(self, userType=None,):
13267 
    self.userType = userType
559 chandransh 13268 
 
13269 
  def read(self, iprot):
13270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13272 
      return
13273 
    iprot.readStructBegin()
13274 
    while True:
13275 
      (fname, ftype, fid) = iprot.readFieldBegin()
13276 
      if ftype == TType.STOP:
13277 
        break
13278 
      if fid == 1:
2981 rajveer 13279 
        if ftype == TType.I32:
13280 
          self.userType = iprot.readI32();
559 chandransh 13281 
        else:
13282 
          iprot.skip(ftype)
13283 
      else:
13284 
        iprot.skip(ftype)
13285 
      iprot.readFieldEnd()
13286 
    iprot.readStructEnd()
13287 
 
13288 
  def write(self, oprot):
13289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13291 
      return
2981 rajveer 13292 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13293 
    if self.userType is not None:
2981 rajveer 13294 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13295 
      oprot.writeI32(self.userType)
559 chandransh 13296 
      oprot.writeFieldEnd()
13297 
    oprot.writeFieldStop()
13298 
    oprot.writeStructEnd()
13299 
 
3431 rajveer 13300 
  def validate(self):
13301 
    return
13302 
 
13303 
 
559 chandransh 13304 
  def __repr__(self):
13305 
    L = ['%s=%r' % (key, value)
13306 
      for key, value in self.__dict__.iteritems()]
13307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13308 
 
13309 
  def __eq__(self, other):
13310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13311 
 
13312 
  def __ne__(self, other):
13313 
    return not (self == other)
13314 
 
2981 rajveer 13315 
class getUserCount_result:
94 ashish 13316 
  """
13317 
  Attributes:
13318 
   - success
13319 
  """
13320 
 
13321 
  thrift_spec = (
2981 rajveer 13322 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13323 
  )
13324 
 
2981 rajveer 13325 
  def __init__(self, success=None,):
94 ashish 13326 
    self.success = success
13327 
 
13328 
  def read(self, iprot):
13329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13331 
      return
13332 
    iprot.readStructBegin()
13333 
    while True:
13334 
      (fname, ftype, fid) = iprot.readFieldBegin()
13335 
      if ftype == TType.STOP:
13336 
        break
13337 
      if fid == 0:
2981 rajveer 13338 
        if ftype == TType.I64:
13339 
          self.success = iprot.readI64();
94 ashish 13340 
        else:
13341 
          iprot.skip(ftype)
13342 
      else:
13343 
        iprot.skip(ftype)
13344 
      iprot.readFieldEnd()
13345 
    iprot.readStructEnd()
13346 
 
13347 
  def write(self, oprot):
13348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13350 
      return
2981 rajveer 13351 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13352 
    if self.success is not None:
2981 rajveer 13353 
      oprot.writeFieldBegin('success', TType.I64, 0)
13354 
      oprot.writeI64(self.success)
94 ashish 13355 
      oprot.writeFieldEnd()
13356 
    oprot.writeFieldStop()
13357 
    oprot.writeStructEnd()
13358 
 
3431 rajveer 13359 
  def validate(self):
13360 
    return
13361 
 
13362 
 
94 ashish 13363 
  def __repr__(self):
13364 
    L = ['%s=%r' % (key, value)
13365 
      for key, value in self.__dict__.iteritems()]
13366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13367 
 
13368 
  def __eq__(self, other):
13369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13370 
 
13371 
  def __ne__(self, other):
13372 
    return not (self == other)
13373 
 
2981 rajveer 13374 
class getAllUsers_args:
94 ashish 13375 
  """
13376 
  Attributes:
2981 rajveer 13377 
   - userType
13378 
   - startDate
13379 
   - endDate
94 ashish 13380 
  """
13381 
 
13382 
  thrift_spec = (
13383 
    None, # 0
2981 rajveer 13384 
    (1, TType.I32, 'userType', None, None, ), # 1
13385 
    (2, TType.I64, 'startDate', None, None, ), # 2
13386 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13387 
  )
13388 
 
2981 rajveer 13389 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13390 
    self.userType = userType
13391 
    self.startDate = startDate
13392 
    self.endDate = endDate
94 ashish 13393 
 
13394 
  def read(self, iprot):
13395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13397 
      return
13398 
    iprot.readStructBegin()
13399 
    while True:
13400 
      (fname, ftype, fid) = iprot.readFieldBegin()
13401 
      if ftype == TType.STOP:
13402 
        break
13403 
      if fid == 1:
2981 rajveer 13404 
        if ftype == TType.I32:
13405 
          self.userType = iprot.readI32();
94 ashish 13406 
        else:
13407 
          iprot.skip(ftype)
13408 
      elif fid == 2:
559 chandransh 13409 
        if ftype == TType.I64:
2981 rajveer 13410 
          self.startDate = iprot.readI64();
94 ashish 13411 
        else:
13412 
          iprot.skip(ftype)
2981 rajveer 13413 
      elif fid == 3:
13414 
        if ftype == TType.I64:
13415 
          self.endDate = iprot.readI64();
13416 
        else:
13417 
          iprot.skip(ftype)
94 ashish 13418 
      else:
13419 
        iprot.skip(ftype)
13420 
      iprot.readFieldEnd()
13421 
    iprot.readStructEnd()
13422 
 
13423 
  def write(self, oprot):
13424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13426 
      return
2981 rajveer 13427 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13428 
    if self.userType is not None:
2981 rajveer 13429 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13430 
      oprot.writeI32(self.userType)
94 ashish 13431 
      oprot.writeFieldEnd()
3431 rajveer 13432 
    if self.startDate is not None:
2981 rajveer 13433 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13434 
      oprot.writeI64(self.startDate)
94 ashish 13435 
      oprot.writeFieldEnd()
3431 rajveer 13436 
    if self.endDate is not None:
2981 rajveer 13437 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13438 
      oprot.writeI64(self.endDate)
13439 
      oprot.writeFieldEnd()
94 ashish 13440 
    oprot.writeFieldStop()
13441 
    oprot.writeStructEnd()
13442 
 
3431 rajveer 13443 
  def validate(self):
13444 
    return
13445 
 
13446 
 
94 ashish 13447 
  def __repr__(self):
13448 
    L = ['%s=%r' % (key, value)
13449 
      for key, value in self.__dict__.iteritems()]
13450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13451 
 
13452 
  def __eq__(self, other):
13453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13454 
 
13455 
  def __ne__(self, other):
13456 
    return not (self == other)
13457 
 
2981 rajveer 13458 
class getAllUsers_result:
94 ashish 13459 
  """
13460 
  Attributes:
13461 
   - success
13462 
  """
13463 
 
13464 
  thrift_spec = (
2981 rajveer 13465 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13466 
  )
13467 
 
2981 rajveer 13468 
  def __init__(self, success=None,):
94 ashish 13469 
    self.success = success
13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 0:
2981 rajveer 13481 
        if ftype == TType.LIST:
13482 
          self.success = []
11980 amit.gupta 13483 
          (_etype193, _size190) = iprot.readListBegin()
13484 
          for _i194 in xrange(_size190):
13485 
            _elem195 = User()
13486 
            _elem195.read(iprot)
13487 
            self.success.append(_elem195)
2981 rajveer 13488 
          iprot.readListEnd()
94 ashish 13489 
        else:
13490 
          iprot.skip(ftype)
13491 
      else:
13492 
        iprot.skip(ftype)
13493 
      iprot.readFieldEnd()
13494 
    iprot.readStructEnd()
13495 
 
13496 
  def write(self, oprot):
13497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13499 
      return
2981 rajveer 13500 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13501 
    if self.success is not None:
2981 rajveer 13502 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13503 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13504 
      for iter196 in self.success:
13505 
        iter196.write(oprot)
2981 rajveer 13506 
      oprot.writeListEnd()
94 ashish 13507 
      oprot.writeFieldEnd()
13508 
    oprot.writeFieldStop()
13509 
    oprot.writeStructEnd()
13510 
 
3431 rajveer 13511 
  def validate(self):
13512 
    return
13513 
 
13514 
 
94 ashish 13515 
  def __repr__(self):
13516 
    L = ['%s=%r' % (key, value)
13517 
      for key, value in self.__dict__.iteritems()]
13518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13519 
 
13520 
  def __eq__(self, other):
13521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13522 
 
13523 
  def __ne__(self, other):
13524 
    return not (self == other)
13525 
 
2981 rajveer 13526 
class getMyResearchItems_args:
559 chandransh 13527 
  """
13528 
  Attributes:
772 rajveer 13529 
   - userId
559 chandransh 13530 
  """
13531 
 
13532 
  thrift_spec = (
13533 
    None, # 0
772 rajveer 13534 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13535 
  )
13536 
 
772 rajveer 13537 
  def __init__(self, userId=None,):
13538 
    self.userId = userId
559 chandransh 13539 
 
13540 
  def read(self, iprot):
13541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13543 
      return
13544 
    iprot.readStructBegin()
13545 
    while True:
13546 
      (fname, ftype, fid) = iprot.readFieldBegin()
13547 
      if ftype == TType.STOP:
13548 
        break
13549 
      if fid == 1:
13550 
        if ftype == TType.I64:
772 rajveer 13551 
          self.userId = iprot.readI64();
559 chandransh 13552 
        else:
13553 
          iprot.skip(ftype)
13554 
      else:
13555 
        iprot.skip(ftype)
13556 
      iprot.readFieldEnd()
13557 
    iprot.readStructEnd()
13558 
 
13559 
  def write(self, oprot):
13560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13562 
      return
2981 rajveer 13563 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13564 
    if self.userId is not None:
772 rajveer 13565 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13566 
      oprot.writeI64(self.userId)
559 chandransh 13567 
      oprot.writeFieldEnd()
13568 
    oprot.writeFieldStop()
13569 
    oprot.writeStructEnd()
13570 
 
3431 rajveer 13571 
  def validate(self):
13572 
    return
13573 
 
13574 
 
559 chandransh 13575 
  def __repr__(self):
13576 
    L = ['%s=%r' % (key, value)
13577 
      for key, value in self.__dict__.iteritems()]
13578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13579 
 
13580 
  def __eq__(self, other):
13581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13582 
 
13583 
  def __ne__(self, other):
13584 
    return not (self == other)
13585 
 
2981 rajveer 13586 
class getMyResearchItems_result:
559 chandransh 13587 
  """
13588 
  Attributes:
130 ashish 13589 
   - success
559 chandransh 13590 
   - scx
130 ashish 13591 
  """
13592 
 
13593 
  thrift_spec = (
2981 rajveer 13594 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13595 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13596 
  )
13597 
 
559 chandransh 13598 
  def __init__(self, success=None, scx=None,):
130 ashish 13599 
    self.success = success
559 chandransh 13600 
    self.scx = scx
130 ashish 13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
2981 rajveer 13612 
        if ftype == TType.LIST:
13613 
          self.success = []
11980 amit.gupta 13614 
          (_etype200, _size197) = iprot.readListBegin()
13615 
          for _i201 in xrange(_size197):
13616 
            _elem202 = iprot.readI64();
13617 
            self.success.append(_elem202)
2981 rajveer 13618 
          iprot.readListEnd()
130 ashish 13619 
        else:
13620 
          iprot.skip(ftype)
13621 
      elif fid == 1:
13622 
        if ftype == TType.STRUCT:
559 chandransh 13623 
          self.scx = WidgetException()
13624 
          self.scx.read(iprot)
130 ashish 13625 
        else:
13626 
          iprot.skip(ftype)
13627 
      else:
13628 
        iprot.skip(ftype)
13629 
      iprot.readFieldEnd()
13630 
    iprot.readStructEnd()
13631 
 
13632 
  def write(self, oprot):
13633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13635 
      return
2981 rajveer 13636 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13637 
    if self.success is not None:
2981 rajveer 13638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13639 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13640 
      for iter203 in self.success:
13641 
        oprot.writeI64(iter203)
2981 rajveer 13642 
      oprot.writeListEnd()
130 ashish 13643 
      oprot.writeFieldEnd()
3431 rajveer 13644 
    if self.scx is not None:
559 chandransh 13645 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13646 
      self.scx.write(oprot)
130 ashish 13647 
      oprot.writeFieldEnd()
13648 
    oprot.writeFieldStop()
13649 
    oprot.writeStructEnd()
13650 
 
3431 rajveer 13651 
  def validate(self):
13652 
    return
13653 
 
13654 
 
130 ashish 13655 
  def __repr__(self):
13656 
    L = ['%s=%r' % (key, value)
13657 
      for key, value in self.__dict__.iteritems()]
13658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13659 
 
13660 
  def __eq__(self, other):
13661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13662 
 
13663 
  def __ne__(self, other):
13664 
    return not (self == other)
13665 
 
2981 rajveer 13666 
class updateMyResearch_args:
130 ashish 13667 
  """
13668 
  Attributes:
2981 rajveer 13669 
   - userId
13670 
   - itemId
130 ashish 13671 
  """
13672 
 
13673 
  thrift_spec = (
13674 
    None, # 0
2981 rajveer 13675 
    (1, TType.I64, 'userId', None, None, ), # 1
13676 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13677 
  )
13678 
 
2981 rajveer 13679 
  def __init__(self, userId=None, itemId=None,):
13680 
    self.userId = userId
13681 
    self.itemId = itemId
130 ashish 13682 
 
13683 
  def read(self, iprot):
13684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13686 
      return
13687 
    iprot.readStructBegin()
13688 
    while True:
13689 
      (fname, ftype, fid) = iprot.readFieldBegin()
13690 
      if ftype == TType.STOP:
13691 
        break
13692 
      if fid == 1:
559 chandransh 13693 
        if ftype == TType.I64:
2981 rajveer 13694 
          self.userId = iprot.readI64();
130 ashish 13695 
        else:
13696 
          iprot.skip(ftype)
13697 
      elif fid == 2:
559 chandransh 13698 
        if ftype == TType.I64:
2981 rajveer 13699 
          self.itemId = iprot.readI64();
559 chandransh 13700 
        else:
13701 
          iprot.skip(ftype)
130 ashish 13702 
      else:
13703 
        iprot.skip(ftype)
13704 
      iprot.readFieldEnd()
13705 
    iprot.readStructEnd()
13706 
 
13707 
  def write(self, oprot):
13708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13710 
      return
2981 rajveer 13711 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13712 
    if self.userId is not None:
2981 rajveer 13713 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13714 
      oprot.writeI64(self.userId)
130 ashish 13715 
      oprot.writeFieldEnd()
3431 rajveer 13716 
    if self.itemId is not None:
2981 rajveer 13717 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13718 
      oprot.writeI64(self.itemId)
130 ashish 13719 
      oprot.writeFieldEnd()
13720 
    oprot.writeFieldStop()
13721 
    oprot.writeStructEnd()
13722 
 
3431 rajveer 13723 
  def validate(self):
13724 
    return
13725 
 
13726 
 
130 ashish 13727 
  def __repr__(self):
13728 
    L = ['%s=%r' % (key, value)
13729 
      for key, value in self.__dict__.iteritems()]
13730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13731 
 
13732 
  def __eq__(self, other):
13733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13734 
 
13735 
  def __ne__(self, other):
13736 
    return not (self == other)
13737 
 
2981 rajveer 13738 
class updateMyResearch_result:
13739 
  """
13740 
  Attributes:
13741 
   - success
13742 
   - scx
13743 
  """
559 chandransh 13744 
 
13745 
  thrift_spec = (
2981 rajveer 13746 
    (0, TType.BOOL, 'success', None, None, ), # 0
13747 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13748 
  )
13749 
 
2981 rajveer 13750 
  def __init__(self, success=None, scx=None,):
13751 
    self.success = success
13752 
    self.scx = scx
13753 
 
559 chandransh 13754 
  def read(self, iprot):
13755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13757 
      return
13758 
    iprot.readStructBegin()
13759 
    while True:
13760 
      (fname, ftype, fid) = iprot.readFieldBegin()
13761 
      if ftype == TType.STOP:
13762 
        break
2981 rajveer 13763 
      if fid == 0:
13764 
        if ftype == TType.BOOL:
13765 
          self.success = iprot.readBool();
13766 
        else:
13767 
          iprot.skip(ftype)
13768 
      elif fid == 1:
13769 
        if ftype == TType.STRUCT:
13770 
          self.scx = WidgetException()
13771 
          self.scx.read(iprot)
13772 
        else:
13773 
          iprot.skip(ftype)
559 chandransh 13774 
      else:
13775 
        iprot.skip(ftype)
13776 
      iprot.readFieldEnd()
13777 
    iprot.readStructEnd()
13778 
 
13779 
  def write(self, oprot):
13780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13782 
      return
2981 rajveer 13783 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13784 
    if self.success is not None:
2981 rajveer 13785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13786 
      oprot.writeBool(self.success)
13787 
      oprot.writeFieldEnd()
3431 rajveer 13788 
    if self.scx is not None:
2981 rajveer 13789 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13790 
      self.scx.write(oprot)
13791 
      oprot.writeFieldEnd()
559 chandransh 13792 
    oprot.writeFieldStop()
13793 
    oprot.writeStructEnd()
13794 
 
3431 rajveer 13795 
  def validate(self):
13796 
    return
13797 
 
13798 
 
559 chandransh 13799 
  def __repr__(self):
13800 
    L = ['%s=%r' % (key, value)
13801 
      for key, value in self.__dict__.iteritems()]
13802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13803 
 
13804 
  def __eq__(self, other):
13805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13806 
 
13807 
  def __ne__(self, other):
13808 
    return not (self == other)
13809 
 
2981 rajveer 13810 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13811 
  """
13812 
  Attributes:
2981 rajveer 13813 
   - userId
13814 
   - itemId
1596 ankur.sing 13815 
  """
559 chandransh 13816 
 
1596 ankur.sing 13817 
  thrift_spec = (
13818 
    None, # 0
2981 rajveer 13819 
    (1, TType.I64, 'userId', None, None, ), # 1
13820 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13821 
  )
13822 
 
2981 rajveer 13823 
  def __init__(self, userId=None, itemId=None,):
13824 
    self.userId = userId
13825 
    self.itemId = itemId
1596 ankur.sing 13826 
 
13827 
  def read(self, iprot):
13828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13830 
      return
13831 
    iprot.readStructBegin()
13832 
    while True:
13833 
      (fname, ftype, fid) = iprot.readFieldBegin()
13834 
      if ftype == TType.STOP:
13835 
        break
13836 
      if fid == 1:
2981 rajveer 13837 
        if ftype == TType.I64:
13838 
          self.userId = iprot.readI64();
1596 ankur.sing 13839 
        else:
13840 
          iprot.skip(ftype)
2981 rajveer 13841 
      elif fid == 2:
13842 
        if ftype == TType.I64:
13843 
          self.itemId = iprot.readI64();
13844 
        else:
13845 
          iprot.skip(ftype)
1596 ankur.sing 13846 
      else:
13847 
        iprot.skip(ftype)
13848 
      iprot.readFieldEnd()
13849 
    iprot.readStructEnd()
13850 
 
13851 
  def write(self, oprot):
13852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13854 
      return
2981 rajveer 13855 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13856 
    if self.userId is not None:
2981 rajveer 13857 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13858 
      oprot.writeI64(self.userId)
1596 ankur.sing 13859 
      oprot.writeFieldEnd()
3431 rajveer 13860 
    if self.itemId is not None:
2981 rajveer 13861 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13862 
      oprot.writeI64(self.itemId)
13863 
      oprot.writeFieldEnd()
1596 ankur.sing 13864 
    oprot.writeFieldStop()
13865 
    oprot.writeStructEnd()
13866 
 
3431 rajveer 13867 
  def validate(self):
13868 
    return
13869 
 
13870 
 
1596 ankur.sing 13871 
  def __repr__(self):
13872 
    L = ['%s=%r' % (key, value)
13873 
      for key, value in self.__dict__.iteritems()]
13874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13875 
 
13876 
  def __eq__(self, other):
13877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13878 
 
13879 
  def __ne__(self, other):
13880 
    return not (self == other)
13881 
 
2981 rajveer 13882 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13883 
  """
13884 
  Attributes:
2981 rajveer 13885 
   - scx
1596 ankur.sing 13886 
  """
13887 
 
13888 
  thrift_spec = (
2981 rajveer 13889 
    None, # 0
13890 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13891 
  )
13892 
 
2981 rajveer 13893 
  def __init__(self, scx=None,):
13894 
    self.scx = scx
1596 ankur.sing 13895 
 
13896 
  def read(self, iprot):
13897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13899 
      return
13900 
    iprot.readStructBegin()
13901 
    while True:
13902 
      (fname, ftype, fid) = iprot.readFieldBegin()
13903 
      if ftype == TType.STOP:
13904 
        break
2981 rajveer 13905 
      if fid == 1:
13906 
        if ftype == TType.STRUCT:
13907 
          self.scx = WidgetException()
13908 
          self.scx.read(iprot)
1596 ankur.sing 13909 
        else:
13910 
          iprot.skip(ftype)
13911 
      else:
13912 
        iprot.skip(ftype)
13913 
      iprot.readFieldEnd()
13914 
    iprot.readStructEnd()
13915 
 
13916 
  def write(self, oprot):
13917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13919 
      return
2981 rajveer 13920 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13921 
    if self.scx is not None:
2981 rajveer 13922 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13923 
      self.scx.write(oprot)
1596 ankur.sing 13924 
      oprot.writeFieldEnd()
13925 
    oprot.writeFieldStop()
13926 
    oprot.writeStructEnd()
13927 
 
3431 rajveer 13928 
  def validate(self):
13929 
    return
13930 
 
13931 
 
1596 ankur.sing 13932 
  def __repr__(self):
13933 
    L = ['%s=%r' % (key, value)
13934 
      for key, value in self.__dict__.iteritems()]
13935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13936 
 
13937 
  def __eq__(self, other):
13938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13939 
 
13940 
  def __ne__(self, other):
13941 
    return not (self == other)
13942 
 
2981 rajveer 13943 
class getBrowseHistoryItems_args:
1673 ankur.sing 13944 
  """
13945 
  Attributes:
2981 rajveer 13946 
   - userId
1673 ankur.sing 13947 
  """
1596 ankur.sing 13948 
 
1673 ankur.sing 13949 
  thrift_spec = (
13950 
    None, # 0
2981 rajveer 13951 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13952 
  )
13953 
 
2981 rajveer 13954 
  def __init__(self, userId=None,):
13955 
    self.userId = userId
1673 ankur.sing 13956 
 
13957 
  def read(self, iprot):
13958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13960 
      return
13961 
    iprot.readStructBegin()
13962 
    while True:
13963 
      (fname, ftype, fid) = iprot.readFieldBegin()
13964 
      if ftype == TType.STOP:
13965 
        break
13966 
      if fid == 1:
1891 ankur.sing 13967 
        if ftype == TType.I64:
2981 rajveer 13968 
          self.userId = iprot.readI64();
1891 ankur.sing 13969 
        else:
13970 
          iprot.skip(ftype)
1673 ankur.sing 13971 
      else:
13972 
        iprot.skip(ftype)
13973 
      iprot.readFieldEnd()
13974 
    iprot.readStructEnd()
13975 
 
13976 
  def write(self, oprot):
13977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13979 
      return
2981 rajveer 13980 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13981 
    if self.userId is not None:
2981 rajveer 13982 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13983 
      oprot.writeI64(self.userId)
1673 ankur.sing 13984 
      oprot.writeFieldEnd()
13985 
    oprot.writeFieldStop()
13986 
    oprot.writeStructEnd()
13987 
 
3431 rajveer 13988 
  def validate(self):
13989 
    return
13990 
 
13991 
 
1673 ankur.sing 13992 
  def __repr__(self):
13993 
    L = ['%s=%r' % (key, value)
13994 
      for key, value in self.__dict__.iteritems()]
13995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13996 
 
13997 
  def __eq__(self, other):
13998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13999 
 
14000 
  def __ne__(self, other):
14001 
    return not (self == other)
14002 
 
2981 rajveer 14003 
class getBrowseHistoryItems_result:
1673 ankur.sing 14004 
  """
14005 
  Attributes:
14006 
   - success
2981 rajveer 14007 
   - scx
1673 ankur.sing 14008 
  """
14009 
 
14010 
  thrift_spec = (
2981 rajveer 14011 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14012 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 14013 
  )
14014 
 
2981 rajveer 14015 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 14016 
    self.success = success
2981 rajveer 14017 
    self.scx = scx
1673 ankur.sing 14018 
 
14019 
  def read(self, iprot):
14020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14022 
      return
14023 
    iprot.readStructBegin()
14024 
    while True:
14025 
      (fname, ftype, fid) = iprot.readFieldBegin()
14026 
      if ftype == TType.STOP:
14027 
        break
14028 
      if fid == 0:
14029 
        if ftype == TType.LIST:
14030 
          self.success = []
11980 amit.gupta 14031 
          (_etype207, _size204) = iprot.readListBegin()
14032 
          for _i208 in xrange(_size204):
14033 
            _elem209 = iprot.readI64();
14034 
            self.success.append(_elem209)
1673 ankur.sing 14035 
          iprot.readListEnd()
14036 
        else:
14037 
          iprot.skip(ftype)
2981 rajveer 14038 
      elif fid == 1:
14039 
        if ftype == TType.STRUCT:
14040 
          self.scx = WidgetException()
14041 
          self.scx.read(iprot)
14042 
        else:
14043 
          iprot.skip(ftype)
1673 ankur.sing 14044 
      else:
14045 
        iprot.skip(ftype)
14046 
      iprot.readFieldEnd()
14047 
    iprot.readStructEnd()
14048 
 
14049 
  def write(self, oprot):
14050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14052 
      return
2981 rajveer 14053 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 14054 
    if self.success is not None:
1673 ankur.sing 14055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 14056 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14057 
      for iter210 in self.success:
14058 
        oprot.writeI64(iter210)
1673 ankur.sing 14059 
      oprot.writeListEnd()
14060 
      oprot.writeFieldEnd()
3431 rajveer 14061 
    if self.scx is not None:
2981 rajveer 14062 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
14063 
      self.scx.write(oprot)
2642 varun.gupt 14064 
      oprot.writeFieldEnd()
14065 
    oprot.writeFieldStop()
14066 
    oprot.writeStructEnd()
14067 
 
3431 rajveer 14068 
  def validate(self):
14069 
    return
14070 
 
14071 
 
2642 varun.gupt 14072 
  def __repr__(self):
14073 
    L = ['%s=%r' % (key, value)
14074 
      for key, value in self.__dict__.iteritems()]
14075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14076 
 
14077 
  def __eq__(self, other):
14078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14079 
 
14080 
  def __ne__(self, other):
14081 
    return not (self == other)
14082 
 
2981 rajveer 14083 
class updateBrowseHistory_args:
2642 varun.gupt 14084 
  """
14085 
  Attributes:
2981 rajveer 14086 
   - userId
14087 
   - itemId
2642 varun.gupt 14088 
  """
14089 
 
14090 
  thrift_spec = (
14091 
    None, # 0
2981 rajveer 14092 
    (1, TType.I64, 'userId', None, None, ), # 1
14093 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 14094 
  )
14095 
 
2981 rajveer 14096 
  def __init__(self, userId=None, itemId=None,):
14097 
    self.userId = userId
14098 
    self.itemId = itemId
2642 varun.gupt 14099 
 
14100 
  def read(self, iprot):
14101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14103 
      return
14104 
    iprot.readStructBegin()
14105 
    while True:
14106 
      (fname, ftype, fid) = iprot.readFieldBegin()
14107 
      if ftype == TType.STOP:
14108 
        break
14109 
      if fid == 1:
14110 
        if ftype == TType.I64:
2981 rajveer 14111 
          self.userId = iprot.readI64();
2642 varun.gupt 14112 
        else:
14113 
          iprot.skip(ftype)
14114 
      elif fid == 2:
14115 
        if ftype == TType.I64:
2981 rajveer 14116 
          self.itemId = iprot.readI64();
2642 varun.gupt 14117 
        else:
14118 
          iprot.skip(ftype)
14119 
      else:
14120 
        iprot.skip(ftype)
14121 
      iprot.readFieldEnd()
14122 
    iprot.readStructEnd()
14123 
 
14124 
  def write(self, oprot):
14125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14127 
      return
2981 rajveer 14128 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14129 
    if self.userId is not None:
2981 rajveer 14130 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14131 
      oprot.writeI64(self.userId)
2642 varun.gupt 14132 
      oprot.writeFieldEnd()
3431 rajveer 14133 
    if self.itemId is not None:
2981 rajveer 14134 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14135 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14136 
      oprot.writeFieldEnd()
14137 
    oprot.writeFieldStop()
14138 
    oprot.writeStructEnd()
14139 
 
3431 rajveer 14140 
  def validate(self):
14141 
    return
14142 
 
14143 
 
2642 varun.gupt 14144 
  def __repr__(self):
14145 
    L = ['%s=%r' % (key, value)
14146 
      for key, value in self.__dict__.iteritems()]
14147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14148 
 
14149 
  def __eq__(self, other):
14150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14151 
 
14152 
  def __ne__(self, other):
14153 
    return not (self == other)
14154 
 
2981 rajveer 14155 
class updateBrowseHistory_result:
2642 varun.gupt 14156 
 
14157 
  thrift_spec = (
14158 
  )
14159 
 
14160 
  def read(self, iprot):
14161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14163 
      return
14164 
    iprot.readStructBegin()
14165 
    while True:
14166 
      (fname, ftype, fid) = iprot.readFieldBegin()
14167 
      if ftype == TType.STOP:
14168 
        break
14169 
      else:
14170 
        iprot.skip(ftype)
14171 
      iprot.readFieldEnd()
14172 
    iprot.readStructEnd()
14173 
 
14174 
  def write(self, oprot):
14175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14177 
      return
2981 rajveer 14178 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14179 
    oprot.writeFieldStop()
14180 
    oprot.writeStructEnd()
14181 
 
3431 rajveer 14182 
  def validate(self):
14183 
    return
14184 
 
14185 
 
2642 varun.gupt 14186 
  def __repr__(self):
14187 
    L = ['%s=%r' % (key, value)
14188 
      for key, value in self.__dict__.iteritems()]
14189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14190 
 
14191 
  def __eq__(self, other):
14192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14193 
 
14194 
  def __ne__(self, other):
14195 
    return not (self == other)
14196 
 
3385 varun.gupt 14197 
class getCartsWithCouponCount_args:
14198 
  """
14199 
  Attributes:
14200 
   - couponCode
14201 
  """
2642 varun.gupt 14202 
 
3385 varun.gupt 14203 
  thrift_spec = (
14204 
    None, # 0
14205 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14206 
  )
14207 
 
14208 
  def __init__(self, couponCode=None,):
14209 
    self.couponCode = couponCode
14210 
 
14211 
  def read(self, iprot):
14212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14214 
      return
14215 
    iprot.readStructBegin()
14216 
    while True:
14217 
      (fname, ftype, fid) = iprot.readFieldBegin()
14218 
      if ftype == TType.STOP:
14219 
        break
14220 
      if fid == 1:
14221 
        if ftype == TType.STRING:
14222 
          self.couponCode = iprot.readString();
14223 
        else:
14224 
          iprot.skip(ftype)
14225 
      else:
14226 
        iprot.skip(ftype)
14227 
      iprot.readFieldEnd()
14228 
    iprot.readStructEnd()
14229 
 
14230 
  def write(self, oprot):
14231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14233 
      return
14234 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14235 
    if self.couponCode is not None:
3385 varun.gupt 14236 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14237 
      oprot.writeString(self.couponCode)
14238 
      oprot.writeFieldEnd()
14239 
    oprot.writeFieldStop()
14240 
    oprot.writeStructEnd()
14241 
 
3431 rajveer 14242 
  def validate(self):
14243 
    return
14244 
 
14245 
 
3385 varun.gupt 14246 
  def __repr__(self):
14247 
    L = ['%s=%r' % (key, value)
14248 
      for key, value in self.__dict__.iteritems()]
14249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14250 
 
14251 
  def __eq__(self, other):
14252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14253 
 
14254 
  def __ne__(self, other):
14255 
    return not (self == other)
14256 
 
14257 
class getCartsWithCouponCount_result:
14258 
  """
14259 
  Attributes:
14260 
   - success
14261 
  """
14262 
 
14263 
  thrift_spec = (
14264 
    (0, TType.I64, 'success', None, None, ), # 0
14265 
  )
14266 
 
14267 
  def __init__(self, success=None,):
14268 
    self.success = success
14269 
 
14270 
  def read(self, iprot):
14271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14273 
      return
14274 
    iprot.readStructBegin()
14275 
    while True:
14276 
      (fname, ftype, fid) = iprot.readFieldBegin()
14277 
      if ftype == TType.STOP:
14278 
        break
14279 
      if fid == 0:
14280 
        if ftype == TType.I64:
14281 
          self.success = iprot.readI64();
14282 
        else:
14283 
          iprot.skip(ftype)
14284 
      else:
14285 
        iprot.skip(ftype)
14286 
      iprot.readFieldEnd()
14287 
    iprot.readStructEnd()
14288 
 
14289 
  def write(self, oprot):
14290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14292 
      return
14293 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14294 
    if self.success is not None:
3385 varun.gupt 14295 
      oprot.writeFieldBegin('success', TType.I64, 0)
14296 
      oprot.writeI64(self.success)
14297 
      oprot.writeFieldEnd()
14298 
    oprot.writeFieldStop()
14299 
    oprot.writeStructEnd()
14300 
 
3431 rajveer 14301 
  def validate(self):
14302 
    return
14303 
 
14304 
 
3385 varun.gupt 14305 
  def __repr__(self):
14306 
    L = ['%s=%r' % (key, value)
14307 
      for key, value in self.__dict__.iteritems()]
14308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14309 
 
14310 
  def __eq__(self, other):
14311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14312 
 
14313 
  def __ne__(self, other):
14314 
    return not (self == other)
3499 mandeep.dh 14315 
 
14316 
class increaseTrustLevel_args:
14317 
  """
14318 
  Attributes:
14319 
   - userId
14320 
   - trustLevelDelta
14321 
  """
14322 
 
14323 
  thrift_spec = (
14324 
    None, # 0
14325 
    (1, TType.I64, 'userId', None, None, ), # 1
14326 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14327 
  )
14328 
 
14329 
  def __init__(self, userId=None, trustLevelDelta=None,):
14330 
    self.userId = userId
14331 
    self.trustLevelDelta = trustLevelDelta
14332 
 
14333 
  def read(self, iprot):
14334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14336 
      return
14337 
    iprot.readStructBegin()
14338 
    while True:
14339 
      (fname, ftype, fid) = iprot.readFieldBegin()
14340 
      if ftype == TType.STOP:
14341 
        break
14342 
      if fid == 1:
14343 
        if ftype == TType.I64:
14344 
          self.userId = iprot.readI64();
14345 
        else:
14346 
          iprot.skip(ftype)
14347 
      elif fid == 2:
14348 
        if ftype == TType.DOUBLE:
14349 
          self.trustLevelDelta = iprot.readDouble();
14350 
        else:
14351 
          iprot.skip(ftype)
14352 
      else:
14353 
        iprot.skip(ftype)
14354 
      iprot.readFieldEnd()
14355 
    iprot.readStructEnd()
14356 
 
14357 
  def write(self, oprot):
14358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14360 
      return
14361 
    oprot.writeStructBegin('increaseTrustLevel_args')
14362 
    if self.userId is not None:
14363 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14364 
      oprot.writeI64(self.userId)
14365 
      oprot.writeFieldEnd()
14366 
    if self.trustLevelDelta is not None:
14367 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14368 
      oprot.writeDouble(self.trustLevelDelta)
14369 
      oprot.writeFieldEnd()
14370 
    oprot.writeFieldStop()
14371 
    oprot.writeStructEnd()
14372 
 
14373 
  def validate(self):
14374 
    return
14375 
 
14376 
 
14377 
  def __repr__(self):
14378 
    L = ['%s=%r' % (key, value)
14379 
      for key, value in self.__dict__.iteritems()]
14380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14381 
 
14382 
  def __eq__(self, other):
14383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14384 
 
14385 
  def __ne__(self, other):
14386 
    return not (self == other)
4668 varun.gupt 14387 
 
5407 amar.kumar 14388 
class getTrustLevel_args:
14389 
  """
14390 
  Attributes:
14391 
   - userId
14392 
  """
14393 
 
14394 
  thrift_spec = (
14395 
    None, # 0
14396 
    (1, TType.I64, 'userId', None, None, ), # 1
14397 
  )
14398 
 
14399 
  def __init__(self, userId=None,):
14400 
    self.userId = userId
14401 
 
14402 
  def read(self, iprot):
14403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14405 
      return
14406 
    iprot.readStructBegin()
14407 
    while True:
14408 
      (fname, ftype, fid) = iprot.readFieldBegin()
14409 
      if ftype == TType.STOP:
14410 
        break
14411 
      if fid == 1:
14412 
        if ftype == TType.I64:
14413 
          self.userId = iprot.readI64();
14414 
        else:
14415 
          iprot.skip(ftype)
14416 
      else:
14417 
        iprot.skip(ftype)
14418 
      iprot.readFieldEnd()
14419 
    iprot.readStructEnd()
14420 
 
14421 
  def write(self, oprot):
14422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14424 
      return
14425 
    oprot.writeStructBegin('getTrustLevel_args')
14426 
    if self.userId is not None:
14427 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14428 
      oprot.writeI64(self.userId)
14429 
      oprot.writeFieldEnd()
14430 
    oprot.writeFieldStop()
14431 
    oprot.writeStructEnd()
14432 
 
14433 
  def validate(self):
14434 
    return
14435 
 
14436 
 
14437 
  def __repr__(self):
14438 
    L = ['%s=%r' % (key, value)
14439 
      for key, value in self.__dict__.iteritems()]
14440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14441 
 
14442 
  def __eq__(self, other):
14443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14444 
 
14445 
  def __ne__(self, other):
14446 
    return not (self == other)
14447 
 
14448 
class getTrustLevel_result:
14449 
  """
14450 
  Attributes:
14451 
   - success
14452 
  """
14453 
 
14454 
  thrift_spec = (
14455 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14456 
  )
14457 
 
14458 
  def __init__(self, success=None,):
14459 
    self.success = success
14460 
 
14461 
  def read(self, iprot):
14462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14464 
      return
14465 
    iprot.readStructBegin()
14466 
    while True:
14467 
      (fname, ftype, fid) = iprot.readFieldBegin()
14468 
      if ftype == TType.STOP:
14469 
        break
14470 
      if fid == 0:
14471 
        if ftype == TType.DOUBLE:
14472 
          self.success = iprot.readDouble();
14473 
        else:
14474 
          iprot.skip(ftype)
14475 
      else:
14476 
        iprot.skip(ftype)
14477 
      iprot.readFieldEnd()
14478 
    iprot.readStructEnd()
14479 
 
14480 
  def write(self, oprot):
14481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14483 
      return
14484 
    oprot.writeStructBegin('getTrustLevel_result')
14485 
    if self.success is not None:
14486 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14487 
      oprot.writeDouble(self.success)
14488 
      oprot.writeFieldEnd()
14489 
    oprot.writeFieldStop()
14490 
    oprot.writeStructEnd()
14491 
 
14492 
  def validate(self):
14493 
    return
14494 
 
14495 
 
14496 
  def __repr__(self):
14497 
    L = ['%s=%r' % (key, value)
14498 
      for key, value in self.__dict__.iteritems()]
14499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14500 
 
14501 
  def __eq__(self, other):
14502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14503 
 
14504 
  def __ne__(self, other):
14505 
    return not (self == other)
14506 
 
4668 varun.gupt 14507 
class showCODOption_args:
14508 
  """
14509 
  Attributes:
14510 
   - cartId
14511 
   - sourceId
14512 
   - pincode
14513 
  """
14514 
 
14515 
  thrift_spec = (
14516 
    None, # 0
14517 
    (1, TType.I64, 'cartId', None, None, ), # 1
14518 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14519 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14520 
  )
14521 
 
14522 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14523 
    self.cartId = cartId
14524 
    self.sourceId = sourceId
14525 
    self.pincode = pincode
14526 
 
14527 
  def read(self, iprot):
14528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14530 
      return
14531 
    iprot.readStructBegin()
14532 
    while True:
14533 
      (fname, ftype, fid) = iprot.readFieldBegin()
14534 
      if ftype == TType.STOP:
14535 
        break
14536 
      if fid == 1:
14537 
        if ftype == TType.I64:
14538 
          self.cartId = iprot.readI64();
14539 
        else:
14540 
          iprot.skip(ftype)
14541 
      elif fid == 2:
14542 
        if ftype == TType.I64:
14543 
          self.sourceId = iprot.readI64();
14544 
        else:
14545 
          iprot.skip(ftype)
14546 
      elif fid == 3:
14547 
        if ftype == TType.STRING:
14548 
          self.pincode = iprot.readString();
14549 
        else:
14550 
          iprot.skip(ftype)
14551 
      else:
14552 
        iprot.skip(ftype)
14553 
      iprot.readFieldEnd()
14554 
    iprot.readStructEnd()
14555 
 
14556 
  def write(self, oprot):
14557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14559 
      return
14560 
    oprot.writeStructBegin('showCODOption_args')
14561 
    if self.cartId is not None:
14562 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14563 
      oprot.writeI64(self.cartId)
14564 
      oprot.writeFieldEnd()
14565 
    if self.sourceId is not None:
14566 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14567 
      oprot.writeI64(self.sourceId)
14568 
      oprot.writeFieldEnd()
14569 
    if self.pincode is not None:
14570 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14571 
      oprot.writeString(self.pincode)
14572 
      oprot.writeFieldEnd()
14573 
    oprot.writeFieldStop()
14574 
    oprot.writeStructEnd()
14575 
 
14576 
  def validate(self):
14577 
    return
14578 
 
14579 
 
14580 
  def __repr__(self):
14581 
    L = ['%s=%r' % (key, value)
14582 
      for key, value in self.__dict__.iteritems()]
14583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14584 
 
14585 
  def __eq__(self, other):
14586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14587 
 
14588 
  def __ne__(self, other):
14589 
    return not (self == other)
14590 
 
14591 
class showCODOption_result:
14592 
  """
14593 
  Attributes:
14594 
   - success
14595 
  """
14596 
 
14597 
  thrift_spec = (
14598 
    (0, TType.BOOL, 'success', None, None, ), # 0
14599 
  )
14600 
 
14601 
  def __init__(self, success=None,):
14602 
    self.success = success
14603 
 
14604 
  def read(self, iprot):
14605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14607 
      return
14608 
    iprot.readStructBegin()
14609 
    while True:
14610 
      (fname, ftype, fid) = iprot.readFieldBegin()
14611 
      if ftype == TType.STOP:
14612 
        break
14613 
      if fid == 0:
14614 
        if ftype == TType.BOOL:
14615 
          self.success = iprot.readBool();
14616 
        else:
14617 
          iprot.skip(ftype)
14618 
      else:
14619 
        iprot.skip(ftype)
14620 
      iprot.readFieldEnd()
14621 
    iprot.readStructEnd()
14622 
 
14623 
  def write(self, oprot):
14624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14626 
      return
14627 
    oprot.writeStructBegin('showCODOption_result')
14628 
    if self.success is not None:
14629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14630 
      oprot.writeBool(self.success)
14631 
      oprot.writeFieldEnd()
14632 
    oprot.writeFieldStop()
14633 
    oprot.writeStructEnd()
14634 
 
14635 
  def validate(self):
14636 
    return
14637 
 
14638 
 
14639 
  def __repr__(self):
14640 
    L = ['%s=%r' % (key, value)
14641 
      for key, value in self.__dict__.iteritems()]
14642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14643 
 
14644 
  def __eq__(self, other):
14645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14646 
 
14647 
  def __ne__(self, other):
14648 
    return not (self == other)
5623 anupam.sin 14649 
 
14650 
class getUserEmails_args:
14651 
  """
14652 
  Attributes:
14653 
   - startDate
14654 
   - endDate
14655 
  """
14656 
 
14657 
  thrift_spec = (
14658 
    None, # 0
14659 
    (1, TType.I64, 'startDate', None, None, ), # 1
14660 
    (2, TType.I64, 'endDate', None, None, ), # 2
14661 
  )
14662 
 
14663 
  def __init__(self, startDate=None, endDate=None,):
14664 
    self.startDate = startDate
14665 
    self.endDate = endDate
14666 
 
14667 
  def read(self, iprot):
14668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14670 
      return
14671 
    iprot.readStructBegin()
14672 
    while True:
14673 
      (fname, ftype, fid) = iprot.readFieldBegin()
14674 
      if ftype == TType.STOP:
14675 
        break
14676 
      if fid == 1:
14677 
        if ftype == TType.I64:
14678 
          self.startDate = iprot.readI64();
14679 
        else:
14680 
          iprot.skip(ftype)
14681 
      elif fid == 2:
14682 
        if ftype == TType.I64:
14683 
          self.endDate = iprot.readI64();
14684 
        else:
14685 
          iprot.skip(ftype)
14686 
      else:
14687 
        iprot.skip(ftype)
14688 
      iprot.readFieldEnd()
14689 
    iprot.readStructEnd()
14690 
 
14691 
  def write(self, oprot):
14692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14694 
      return
14695 
    oprot.writeStructBegin('getUserEmails_args')
14696 
    if self.startDate is not None:
14697 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14698 
      oprot.writeI64(self.startDate)
14699 
      oprot.writeFieldEnd()
14700 
    if self.endDate is not None:
14701 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14702 
      oprot.writeI64(self.endDate)
14703 
      oprot.writeFieldEnd()
14704 
    oprot.writeFieldStop()
14705 
    oprot.writeStructEnd()
14706 
 
14707 
  def validate(self):
14708 
    return
14709 
 
14710 
 
14711 
  def __repr__(self):
14712 
    L = ['%s=%r' % (key, value)
14713 
      for key, value in self.__dict__.iteritems()]
14714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14715 
 
14716 
  def __eq__(self, other):
14717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14718 
 
14719 
  def __ne__(self, other):
14720 
    return not (self == other)
14721 
 
14722 
class getUserEmails_result:
14723 
  """
14724 
  Attributes:
14725 
   - success
14726 
  """
14727 
 
14728 
  thrift_spec = (
14729 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14730 
  )
14731 
 
14732 
  def __init__(self, success=None,):
14733 
    self.success = success
14734 
 
14735 
  def read(self, iprot):
14736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14738 
      return
14739 
    iprot.readStructBegin()
14740 
    while True:
14741 
      (fname, ftype, fid) = iprot.readFieldBegin()
14742 
      if ftype == TType.STOP:
14743 
        break
14744 
      if fid == 0:
14745 
        if ftype == TType.LIST:
14746 
          self.success = []
11980 amit.gupta 14747 
          (_etype214, _size211) = iprot.readListBegin()
14748 
          for _i215 in xrange(_size211):
14749 
            _elem216 = iprot.readString();
14750 
            self.success.append(_elem216)
5623 anupam.sin 14751 
          iprot.readListEnd()
14752 
        else:
14753 
          iprot.skip(ftype)
14754 
      else:
14755 
        iprot.skip(ftype)
14756 
      iprot.readFieldEnd()
14757 
    iprot.readStructEnd()
14758 
 
14759 
  def write(self, oprot):
14760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14762 
      return
14763 
    oprot.writeStructBegin('getUserEmails_result')
14764 
    if self.success is not None:
14765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14766 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14767 
      for iter217 in self.success:
14768 
        oprot.writeString(iter217)
5623 anupam.sin 14769 
      oprot.writeListEnd()
14770 
      oprot.writeFieldEnd()
14771 
    oprot.writeFieldStop()
14772 
    oprot.writeStructEnd()
14773 
 
14774 
  def validate(self):
14775 
    return
14776 
 
14777 
 
14778 
  def __repr__(self):
14779 
    L = ['%s=%r' % (key, value)
14780 
      for key, value in self.__dict__.iteritems()]
14781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14782 
 
14783 
  def __eq__(self, other):
14784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14785 
 
14786 
  def __ne__(self, other):
14787 
    return not (self == other)
6821 amar.kumar 14788 
 
6903 anupam.sin 14789 
class insureItem_args:
14790 
  """
14791 
  Attributes:
14792 
   - itemId
14793 
   - cartId
14794 
   - toInsure
9299 kshitij.so 14795 
   - insurerType
6903 anupam.sin 14796 
  """
14797 
 
14798 
  thrift_spec = (
14799 
    None, # 0
14800 
    (1, TType.I64, 'itemId', None, None, ), # 1
14801 
    (2, TType.I64, 'cartId', None, None, ), # 2
14802 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14803 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14804 
  )
14805 
 
9299 kshitij.so 14806 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14807 
    self.itemId = itemId
14808 
    self.cartId = cartId
14809 
    self.toInsure = toInsure
9299 kshitij.so 14810 
    self.insurerType = insurerType
6903 anupam.sin 14811 
 
14812 
  def read(self, iprot):
14813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14815 
      return
14816 
    iprot.readStructBegin()
14817 
    while True:
14818 
      (fname, ftype, fid) = iprot.readFieldBegin()
14819 
      if ftype == TType.STOP:
14820 
        break
14821 
      if fid == 1:
14822 
        if ftype == TType.I64:
14823 
          self.itemId = iprot.readI64();
14824 
        else:
14825 
          iprot.skip(ftype)
14826 
      elif fid == 2:
14827 
        if ftype == TType.I64:
14828 
          self.cartId = iprot.readI64();
14829 
        else:
14830 
          iprot.skip(ftype)
14831 
      elif fid == 3:
14832 
        if ftype == TType.BOOL:
14833 
          self.toInsure = iprot.readBool();
14834 
        else:
14835 
          iprot.skip(ftype)
9299 kshitij.so 14836 
      elif fid == 4:
14837 
        if ftype == TType.I32:
14838 
          self.insurerType = iprot.readI32();
14839 
        else:
14840 
          iprot.skip(ftype)
6903 anupam.sin 14841 
      else:
14842 
        iprot.skip(ftype)
14843 
      iprot.readFieldEnd()
14844 
    iprot.readStructEnd()
14845 
 
14846 
  def write(self, oprot):
14847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14849 
      return
14850 
    oprot.writeStructBegin('insureItem_args')
14851 
    if self.itemId is not None:
14852 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14853 
      oprot.writeI64(self.itemId)
14854 
      oprot.writeFieldEnd()
14855 
    if self.cartId is not None:
14856 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14857 
      oprot.writeI64(self.cartId)
14858 
      oprot.writeFieldEnd()
14859 
    if self.toInsure is not None:
14860 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14861 
      oprot.writeBool(self.toInsure)
14862 
      oprot.writeFieldEnd()
9299 kshitij.so 14863 
    if self.insurerType is not None:
14864 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14865 
      oprot.writeI32(self.insurerType)
14866 
      oprot.writeFieldEnd()
6903 anupam.sin 14867 
    oprot.writeFieldStop()
14868 
    oprot.writeStructEnd()
14869 
 
14870 
  def validate(self):
14871 
    return
14872 
 
14873 
 
14874 
  def __repr__(self):
14875 
    L = ['%s=%r' % (key, value)
14876 
      for key, value in self.__dict__.iteritems()]
14877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14878 
 
14879 
  def __eq__(self, other):
14880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14881 
 
14882 
  def __ne__(self, other):
14883 
    return not (self == other)
14884 
 
14885 
class insureItem_result:
14886 
  """
14887 
  Attributes:
14888 
   - success
14889 
  """
14890 
 
14891 
  thrift_spec = (
14892 
    (0, TType.BOOL, 'success', None, None, ), # 0
14893 
  )
14894 
 
14895 
  def __init__(self, success=None,):
14896 
    self.success = success
14897 
 
14898 
  def read(self, iprot):
14899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14901 
      return
14902 
    iprot.readStructBegin()
14903 
    while True:
14904 
      (fname, ftype, fid) = iprot.readFieldBegin()
14905 
      if ftype == TType.STOP:
14906 
        break
14907 
      if fid == 0:
14908 
        if ftype == TType.BOOL:
14909 
          self.success = iprot.readBool();
14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      else:
14913 
        iprot.skip(ftype)
14914 
      iprot.readFieldEnd()
14915 
    iprot.readStructEnd()
14916 
 
14917 
  def write(self, oprot):
14918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14920 
      return
14921 
    oprot.writeStructBegin('insureItem_result')
14922 
    if self.success is not None:
14923 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14924 
      oprot.writeBool(self.success)
14925 
      oprot.writeFieldEnd()
14926 
    oprot.writeFieldStop()
14927 
    oprot.writeStructEnd()
14928 
 
14929 
  def validate(self):
14930 
    return
14931 
 
14932 
 
14933 
  def __repr__(self):
14934 
    L = ['%s=%r' % (key, value)
14935 
      for key, value in self.__dict__.iteritems()]
14936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14937 
 
14938 
  def __eq__(self, other):
14939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14940 
 
14941 
  def __ne__(self, other):
14942 
    return not (self == other)
14943 
 
14944 
class cancelInsurance_args:
14945 
  """
14946 
  Attributes:
14947 
   - cartId
14948 
  """
14949 
 
14950 
  thrift_spec = (
14951 
    None, # 0
14952 
    (1, TType.I64, 'cartId', None, None, ), # 1
14953 
  )
14954 
 
14955 
  def __init__(self, cartId=None,):
14956 
    self.cartId = cartId
14957 
 
14958 
  def read(self, iprot):
14959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14961 
      return
14962 
    iprot.readStructBegin()
14963 
    while True:
14964 
      (fname, ftype, fid) = iprot.readFieldBegin()
14965 
      if ftype == TType.STOP:
14966 
        break
14967 
      if fid == 1:
14968 
        if ftype == TType.I64:
14969 
          self.cartId = iprot.readI64();
14970 
        else:
14971 
          iprot.skip(ftype)
14972 
      else:
14973 
        iprot.skip(ftype)
14974 
      iprot.readFieldEnd()
14975 
    iprot.readStructEnd()
14976 
 
14977 
  def write(self, oprot):
14978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14980 
      return
14981 
    oprot.writeStructBegin('cancelInsurance_args')
14982 
    if self.cartId is not None:
14983 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14984 
      oprot.writeI64(self.cartId)
14985 
      oprot.writeFieldEnd()
14986 
    oprot.writeFieldStop()
14987 
    oprot.writeStructEnd()
14988 
 
14989 
  def validate(self):
14990 
    return
14991 
 
14992 
 
14993 
  def __repr__(self):
14994 
    L = ['%s=%r' % (key, value)
14995 
      for key, value in self.__dict__.iteritems()]
14996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14997 
 
14998 
  def __eq__(self, other):
14999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15000 
 
15001 
  def __ne__(self, other):
15002 
    return not (self == other)
15003 
 
15004 
class cancelInsurance_result:
15005 
  """
15006 
  Attributes:
15007 
   - success
15008 
  """
15009 
 
15010 
  thrift_spec = (
15011 
    (0, TType.BOOL, 'success', None, None, ), # 0
15012 
  )
15013 
 
15014 
  def __init__(self, success=None,):
15015 
    self.success = success
15016 
 
15017 
  def read(self, iprot):
15018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15020 
      return
15021 
    iprot.readStructBegin()
15022 
    while True:
15023 
      (fname, ftype, fid) = iprot.readFieldBegin()
15024 
      if ftype == TType.STOP:
15025 
        break
15026 
      if fid == 0:
15027 
        if ftype == TType.BOOL:
15028 
          self.success = iprot.readBool();
15029 
        else:
15030 
          iprot.skip(ftype)
15031 
      else:
15032 
        iprot.skip(ftype)
15033 
      iprot.readFieldEnd()
15034 
    iprot.readStructEnd()
15035 
 
15036 
  def write(self, oprot):
15037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15039 
      return
15040 
    oprot.writeStructBegin('cancelInsurance_result')
15041 
    if self.success is not None:
15042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15043 
      oprot.writeBool(self.success)
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class storeInsuranceSpecificDetails_args:
15064 
  """
15065 
  Attributes:
15066 
   - addressId
15067 
   - dob
15068 
   - guardianName
15069 
  """
15070 
 
15071 
  thrift_spec = (
15072 
    None, # 0
15073 
    (1, TType.I64, 'addressId', None, None, ), # 1
15074 
    (2, TType.STRING, 'dob', None, None, ), # 2
15075 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
15076 
  )
15077 
 
15078 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
15079 
    self.addressId = addressId
15080 
    self.dob = dob
15081 
    self.guardianName = guardianName
15082 
 
15083 
  def read(self, iprot):
15084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15086 
      return
15087 
    iprot.readStructBegin()
15088 
    while True:
15089 
      (fname, ftype, fid) = iprot.readFieldBegin()
15090 
      if ftype == TType.STOP:
15091 
        break
15092 
      if fid == 1:
15093 
        if ftype == TType.I64:
15094 
          self.addressId = iprot.readI64();
15095 
        else:
15096 
          iprot.skip(ftype)
15097 
      elif fid == 2:
15098 
        if ftype == TType.STRING:
15099 
          self.dob = iprot.readString();
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      elif fid == 3:
15103 
        if ftype == TType.STRING:
15104 
          self.guardianName = iprot.readString();
15105 
        else:
15106 
          iprot.skip(ftype)
15107 
      else:
15108 
        iprot.skip(ftype)
15109 
      iprot.readFieldEnd()
15110 
    iprot.readStructEnd()
15111 
 
15112 
  def write(self, oprot):
15113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15115 
      return
15116 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15117 
    if self.addressId is not None:
15118 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15119 
      oprot.writeI64(self.addressId)
15120 
      oprot.writeFieldEnd()
15121 
    if self.dob is not None:
15122 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15123 
      oprot.writeString(self.dob)
15124 
      oprot.writeFieldEnd()
15125 
    if self.guardianName is not None:
15126 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15127 
      oprot.writeString(self.guardianName)
15128 
      oprot.writeFieldEnd()
15129 
    oprot.writeFieldStop()
15130 
    oprot.writeStructEnd()
15131 
 
15132 
  def validate(self):
15133 
    return
15134 
 
15135 
 
15136 
  def __repr__(self):
15137 
    L = ['%s=%r' % (key, value)
15138 
      for key, value in self.__dict__.iteritems()]
15139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15140 
 
15141 
  def __eq__(self, other):
15142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15143 
 
15144 
  def __ne__(self, other):
15145 
    return not (self == other)
15146 
 
15147 
class storeInsuranceSpecificDetails_result:
15148 
  """
15149 
  Attributes:
15150 
   - success
15151 
  """
15152 
 
15153 
  thrift_spec = (
15154 
    (0, TType.BOOL, 'success', None, None, ), # 0
15155 
  )
15156 
 
15157 
  def __init__(self, success=None,):
15158 
    self.success = success
15159 
 
15160 
  def read(self, iprot):
15161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15163 
      return
15164 
    iprot.readStructBegin()
15165 
    while True:
15166 
      (fname, ftype, fid) = iprot.readFieldBegin()
15167 
      if ftype == TType.STOP:
15168 
        break
15169 
      if fid == 0:
15170 
        if ftype == TType.BOOL:
15171 
          self.success = iprot.readBool();
15172 
        else:
15173 
          iprot.skip(ftype)
15174 
      else:
15175 
        iprot.skip(ftype)
15176 
      iprot.readFieldEnd()
15177 
    iprot.readStructEnd()
15178 
 
15179 
  def write(self, oprot):
15180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15182 
      return
15183 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15184 
    if self.success is not None:
15185 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15186 
      oprot.writeBool(self.success)
15187 
      oprot.writeFieldEnd()
15188 
    oprot.writeFieldStop()
15189 
    oprot.writeStructEnd()
15190 
 
15191 
  def validate(self):
15192 
    return
15193 
 
15194 
 
15195 
  def __repr__(self):
15196 
    L = ['%s=%r' % (key, value)
15197 
      for key, value in self.__dict__.iteritems()]
15198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15199 
 
15200 
  def __eq__(self, other):
15201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15202 
 
15203 
  def __ne__(self, other):
15204 
    return not (self == other)
15205 
 
15206 
class isInsuranceDetailPresent_args:
15207 
  """
15208 
  Attributes:
15209 
   - addressId
15210 
  """
15211 
 
15212 
  thrift_spec = (
15213 
    None, # 0
15214 
    (1, TType.I64, 'addressId', None, None, ), # 1
15215 
  )
15216 
 
15217 
  def __init__(self, addressId=None,):
15218 
    self.addressId = addressId
15219 
 
15220 
  def read(self, iprot):
15221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15223 
      return
15224 
    iprot.readStructBegin()
15225 
    while True:
15226 
      (fname, ftype, fid) = iprot.readFieldBegin()
15227 
      if ftype == TType.STOP:
15228 
        break
15229 
      if fid == 1:
15230 
        if ftype == TType.I64:
15231 
          self.addressId = iprot.readI64();
15232 
        else:
15233 
          iprot.skip(ftype)
15234 
      else:
15235 
        iprot.skip(ftype)
15236 
      iprot.readFieldEnd()
15237 
    iprot.readStructEnd()
15238 
 
15239 
  def write(self, oprot):
15240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15242 
      return
15243 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15244 
    if self.addressId is not None:
15245 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15246 
      oprot.writeI64(self.addressId)
15247 
      oprot.writeFieldEnd()
15248 
    oprot.writeFieldStop()
15249 
    oprot.writeStructEnd()
15250 
 
15251 
  def validate(self):
15252 
    return
15253 
 
15254 
 
15255 
  def __repr__(self):
15256 
    L = ['%s=%r' % (key, value)
15257 
      for key, value in self.__dict__.iteritems()]
15258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15259 
 
15260 
  def __eq__(self, other):
15261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15262 
 
15263 
  def __ne__(self, other):
15264 
    return not (self == other)
15265 
 
15266 
class isInsuranceDetailPresent_result:
15267 
  """
15268 
  Attributes:
15269 
   - success
15270 
  """
15271 
 
15272 
  thrift_spec = (
15273 
    (0, TType.BOOL, 'success', None, None, ), # 0
15274 
  )
15275 
 
15276 
  def __init__(self, success=None,):
15277 
    self.success = success
15278 
 
15279 
  def read(self, iprot):
15280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15282 
      return
15283 
    iprot.readStructBegin()
15284 
    while True:
15285 
      (fname, ftype, fid) = iprot.readFieldBegin()
15286 
      if ftype == TType.STOP:
15287 
        break
15288 
      if fid == 0:
15289 
        if ftype == TType.BOOL:
15290 
          self.success = iprot.readBool();
15291 
        else:
15292 
          iprot.skip(ftype)
15293 
      else:
15294 
        iprot.skip(ftype)
15295 
      iprot.readFieldEnd()
15296 
    iprot.readStructEnd()
15297 
 
15298 
  def write(self, oprot):
15299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15301 
      return
15302 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15303 
    if self.success is not None:
15304 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15305 
      oprot.writeBool(self.success)
15306 
      oprot.writeFieldEnd()
15307 
    oprot.writeFieldStop()
15308 
    oprot.writeStructEnd()
15309 
 
15310 
  def validate(self):
15311 
    return
15312 
 
15313 
 
15314 
  def __repr__(self):
15315 
    L = ['%s=%r' % (key, value)
15316 
      for key, value in self.__dict__.iteritems()]
15317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15318 
 
15319 
  def __eq__(self, other):
15320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15321 
 
15322 
  def __ne__(self, other):
15323 
    return not (self == other)
15324 
 
9791 rajveer 15325 
class getProductsAddedToCart_args:
6821 amar.kumar 15326 
  """
15327 
  Attributes:
15328 
   - startDate
15329 
   - endDate
15330 
  """
15331 
 
15332 
  thrift_spec = (
15333 
    None, # 0
9791 rajveer 15334 
    (1, TType.I64, 'startDate', None, None, ), # 1
15335 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15336 
  )
15337 
 
9791 rajveer 15338 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15339 
    self.startDate = startDate
15340 
    self.endDate = endDate
15341 
 
15342 
  def read(self, iprot):
15343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15345 
      return
15346 
    iprot.readStructBegin()
15347 
    while True:
15348 
      (fname, ftype, fid) = iprot.readFieldBegin()
15349 
      if ftype == TType.STOP:
15350 
        break
15351 
      if fid == 1:
15352 
        if ftype == TType.I64:
9791 rajveer 15353 
          self.startDate = iprot.readI64();
6821 amar.kumar 15354 
        else:
15355 
          iprot.skip(ftype)
15356 
      elif fid == 2:
15357 
        if ftype == TType.I64:
15358 
          self.endDate = iprot.readI64();
15359 
        else:
15360 
          iprot.skip(ftype)
15361 
      else:
15362 
        iprot.skip(ftype)
15363 
      iprot.readFieldEnd()
15364 
    iprot.readStructEnd()
15365 
 
15366 
  def write(self, oprot):
15367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15369 
      return
9791 rajveer 15370 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15371 
    if self.startDate is not None:
9791 rajveer 15372 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15373 
      oprot.writeI64(self.startDate)
15374 
      oprot.writeFieldEnd()
15375 
    if self.endDate is not None:
9791 rajveer 15376 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15377 
      oprot.writeI64(self.endDate)
15378 
      oprot.writeFieldEnd()
15379 
    oprot.writeFieldStop()
15380 
    oprot.writeStructEnd()
15381 
 
15382 
  def validate(self):
15383 
    return
15384 
 
15385 
 
15386 
  def __repr__(self):
15387 
    L = ['%s=%r' % (key, value)
15388 
      for key, value in self.__dict__.iteritems()]
15389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15390 
 
15391 
  def __eq__(self, other):
15392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15393 
 
15394 
  def __ne__(self, other):
15395 
    return not (self == other)
15396 
 
9791 rajveer 15397 
class getProductsAddedToCart_result:
6821 amar.kumar 15398 
  """
15399 
  Attributes:
15400 
   - success
15401 
  """
15402 
 
15403 
  thrift_spec = (
9791 rajveer 15404 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15405 
  )
15406 
 
15407 
  def __init__(self, success=None,):
15408 
    self.success = success
15409 
 
15410 
  def read(self, iprot):
15411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15413 
      return
15414 
    iprot.readStructBegin()
15415 
    while True:
15416 
      (fname, ftype, fid) = iprot.readFieldBegin()
15417 
      if ftype == TType.STOP:
15418 
        break
15419 
      if fid == 0:
9791 rajveer 15420 
        if ftype == TType.LIST:
15421 
          self.success = []
11980 amit.gupta 15422 
          (_etype221, _size218) = iprot.readListBegin()
15423 
          for _i222 in xrange(_size218):
15424 
            _elem223 = iprot.readI64();
15425 
            self.success.append(_elem223)
9791 rajveer 15426 
          iprot.readListEnd()
6821 amar.kumar 15427 
        else:
15428 
          iprot.skip(ftype)
15429 
      else:
15430 
        iprot.skip(ftype)
15431 
      iprot.readFieldEnd()
15432 
    iprot.readStructEnd()
15433 
 
15434 
  def write(self, oprot):
15435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15437 
      return
9791 rajveer 15438 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15439 
    if self.success is not None:
9791 rajveer 15440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15441 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15442 
      for iter224 in self.success:
15443 
        oprot.writeI64(iter224)
9791 rajveer 15444 
      oprot.writeListEnd()
6821 amar.kumar 15445 
      oprot.writeFieldEnd()
15446 
    oprot.writeFieldStop()
15447 
    oprot.writeStructEnd()
15448 
 
15449 
  def validate(self):
15450 
    return
15451 
 
15452 
 
15453 
  def __repr__(self):
15454 
    L = ['%s=%r' % (key, value)
15455 
      for key, value in self.__dict__.iteritems()]
15456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15457 
 
15458 
  def __eq__(self, other):
15459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15460 
 
15461 
  def __ne__(self, other):
15462 
    return not (self == other)
11592 amit.gupta 15463 
 
15464 
class validateCartPlus_args:
15465 
  """
15466 
  Attributes:
15467 
   - cartId
15468 
   - sourceId
11980 amit.gupta 15469 
   - dealerCoupon
11592 amit.gupta 15470 
  """
15471 
 
15472 
  thrift_spec = (
15473 
    None, # 0
15474 
    (1, TType.I64, 'cartId', None, None, ), # 1
15475 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15476 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15477 
  )
15478 
 
11980 amit.gupta 15479 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15480 
    self.cartId = cartId
15481 
    self.sourceId = sourceId
11980 amit.gupta 15482 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15483 
 
15484 
  def read(self, iprot):
15485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15487 
      return
15488 
    iprot.readStructBegin()
15489 
    while True:
15490 
      (fname, ftype, fid) = iprot.readFieldBegin()
15491 
      if ftype == TType.STOP:
15492 
        break
15493 
      if fid == 1:
15494 
        if ftype == TType.I64:
15495 
          self.cartId = iprot.readI64();
15496 
        else:
15497 
          iprot.skip(ftype)
15498 
      elif fid == 2:
15499 
        if ftype == TType.I64:
15500 
          self.sourceId = iprot.readI64();
15501 
        else:
15502 
          iprot.skip(ftype)
11980 amit.gupta 15503 
      elif fid == 3:
15504 
        if ftype == TType.STRING:
15505 
          self.dealerCoupon = iprot.readString();
15506 
        else:
15507 
          iprot.skip(ftype)
11592 amit.gupta 15508 
      else:
15509 
        iprot.skip(ftype)
15510 
      iprot.readFieldEnd()
15511 
    iprot.readStructEnd()
15512 
 
15513 
  def write(self, oprot):
15514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15516 
      return
15517 
    oprot.writeStructBegin('validateCartPlus_args')
15518 
    if self.cartId is not None:
15519 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15520 
      oprot.writeI64(self.cartId)
15521 
      oprot.writeFieldEnd()
15522 
    if self.sourceId is not None:
15523 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15524 
      oprot.writeI64(self.sourceId)
15525 
      oprot.writeFieldEnd()
11980 amit.gupta 15526 
    if self.dealerCoupon is not None:
15527 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15528 
      oprot.writeString(self.dealerCoupon)
15529 
      oprot.writeFieldEnd()
11592 amit.gupta 15530 
    oprot.writeFieldStop()
15531 
    oprot.writeStructEnd()
15532 
 
15533 
  def validate(self):
15534 
    return
15535 
 
15536 
 
15537 
  def __repr__(self):
15538 
    L = ['%s=%r' % (key, value)
15539 
      for key, value in self.__dict__.iteritems()]
15540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15541 
 
15542 
  def __eq__(self, other):
15543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15544 
 
15545 
  def __ne__(self, other):
15546 
    return not (self == other)
15547 
 
15548 
class validateCartPlus_result:
15549 
  """
15550 
  Attributes:
15551 
   - success
15552 
   - scex
15553 
  """
15554 
 
15555 
  thrift_spec = (
15556 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15557 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15558 
  )
15559 
 
15560 
  def __init__(self, success=None, scex=None,):
15561 
    self.success = success
15562 
    self.scex = scex
15563 
 
15564 
  def read(self, iprot):
15565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15567 
      return
15568 
    iprot.readStructBegin()
15569 
    while True:
15570 
      (fname, ftype, fid) = iprot.readFieldBegin()
15571 
      if ftype == TType.STOP:
15572 
        break
15573 
      if fid == 0:
15574 
        if ftype == TType.STRUCT:
15575 
          self.success = CartPlus()
15576 
          self.success.read(iprot)
15577 
        else:
15578 
          iprot.skip(ftype)
15579 
      elif fid == 1:
15580 
        if ftype == TType.STRUCT:
15581 
          self.scex = ShoppingCartException()
15582 
          self.scex.read(iprot)
15583 
        else:
15584 
          iprot.skip(ftype)
15585 
      else:
15586 
        iprot.skip(ftype)
15587 
      iprot.readFieldEnd()
15588 
    iprot.readStructEnd()
15589 
 
15590 
  def write(self, oprot):
15591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15593 
      return
15594 
    oprot.writeStructBegin('validateCartPlus_result')
15595 
    if self.success is not None:
15596 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15597 
      self.success.write(oprot)
15598 
      oprot.writeFieldEnd()
15599 
    if self.scex is not None:
15600 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15601 
      self.scex.write(oprot)
15602 
      oprot.writeFieldEnd()
15603 
    oprot.writeFieldStop()
15604 
    oprot.writeStructEnd()
15605 
 
15606 
  def validate(self):
15607 
    return
15608 
 
15609 
 
15610 
  def __repr__(self):
15611 
    L = ['%s=%r' % (key, value)
15612 
      for key, value in self.__dict__.iteritems()]
15613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15614 
 
15615 
  def __eq__(self, other):
15616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15617 
 
15618 
  def __ne__(self, other):
15619 
    return not (self == other)
11679 vikram.rag 15620 
 
15621 
class isPrivateDealUser_args:
15622 
  """
15623 
  Attributes:
15624 
   - userId
15625 
  """
15626 
 
15627 
  thrift_spec = (
15628 
    None, # 0
15629 
    (1, TType.I64, 'userId', None, None, ), # 1
15630 
  )
15631 
 
15632 
  def __init__(self, userId=None,):
15633 
    self.userId = userId
15634 
 
15635 
  def read(self, iprot):
15636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15638 
      return
15639 
    iprot.readStructBegin()
15640 
    while True:
15641 
      (fname, ftype, fid) = iprot.readFieldBegin()
15642 
      if ftype == TType.STOP:
15643 
        break
15644 
      if fid == 1:
15645 
        if ftype == TType.I64:
15646 
          self.userId = iprot.readI64();
15647 
        else:
15648 
          iprot.skip(ftype)
15649 
      else:
15650 
        iprot.skip(ftype)
15651 
      iprot.readFieldEnd()
15652 
    iprot.readStructEnd()
15653 
 
15654 
  def write(self, oprot):
15655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15657 
      return
15658 
    oprot.writeStructBegin('isPrivateDealUser_args')
15659 
    if self.userId is not None:
15660 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15661 
      oprot.writeI64(self.userId)
15662 
      oprot.writeFieldEnd()
15663 
    oprot.writeFieldStop()
15664 
    oprot.writeStructEnd()
15665 
 
15666 
  def validate(self):
15667 
    return
15668 
 
15669 
 
15670 
  def __repr__(self):
15671 
    L = ['%s=%r' % (key, value)
15672 
      for key, value in self.__dict__.iteritems()]
15673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15674 
 
15675 
  def __eq__(self, other):
15676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15677 
 
15678 
  def __ne__(self, other):
15679 
    return not (self == other)
15680 
 
15681 
class isPrivateDealUser_result:
15682 
  """
15683 
  Attributes:
15684 
   - success
15685 
  """
15686 
 
15687 
  thrift_spec = (
15688 
    (0, TType.BOOL, 'success', None, None, ), # 0
15689 
  )
15690 
 
15691 
  def __init__(self, success=None,):
15692 
    self.success = success
15693 
 
15694 
  def read(self, iprot):
15695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15697 
      return
15698 
    iprot.readStructBegin()
15699 
    while True:
15700 
      (fname, ftype, fid) = iprot.readFieldBegin()
15701 
      if ftype == TType.STOP:
15702 
        break
15703 
      if fid == 0:
15704 
        if ftype == TType.BOOL:
15705 
          self.success = iprot.readBool();
15706 
        else:
15707 
          iprot.skip(ftype)
15708 
      else:
15709 
        iprot.skip(ftype)
15710 
      iprot.readFieldEnd()
15711 
    iprot.readStructEnd()
15712 
 
15713 
  def write(self, oprot):
15714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15716 
      return
15717 
    oprot.writeStructBegin('isPrivateDealUser_result')
15718 
    if self.success is not None:
15719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15720 
      oprot.writeBool(self.success)
15721 
      oprot.writeFieldEnd()
15722 
    oprot.writeFieldStop()
15723 
    oprot.writeStructEnd()
15724 
 
15725 
  def validate(self):
15726 
    return
15727 
 
15728 
 
15729 
  def __repr__(self):
15730 
    L = ['%s=%r' % (key, value)
15731 
      for key, value in self.__dict__.iteritems()]
15732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15733 
 
15734 
  def __eq__(self, other):
15735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15736 
 
15737 
  def __ne__(self, other):
15738 
    return not (self == other)
11890 kshitij.so 15739 
 
15740 
class addPrivateDealUser_args:
15741 
  """
15742 
  Attributes:
15743 
   - userId
15744 
  """
15745 
 
15746 
  thrift_spec = (
15747 
    None, # 0
15748 
    (1, TType.I64, 'userId', None, None, ), # 1
15749 
  )
15750 
 
15751 
  def __init__(self, userId=None,):
15752 
    self.userId = userId
15753 
 
15754 
  def read(self, iprot):
15755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15757 
      return
15758 
    iprot.readStructBegin()
15759 
    while True:
15760 
      (fname, ftype, fid) = iprot.readFieldBegin()
15761 
      if ftype == TType.STOP:
15762 
        break
15763 
      if fid == 1:
15764 
        if ftype == TType.I64:
15765 
          self.userId = iprot.readI64();
15766 
        else:
15767 
          iprot.skip(ftype)
15768 
      else:
15769 
        iprot.skip(ftype)
15770 
      iprot.readFieldEnd()
15771 
    iprot.readStructEnd()
15772 
 
15773 
  def write(self, oprot):
15774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15776 
      return
15777 
    oprot.writeStructBegin('addPrivateDealUser_args')
15778 
    if self.userId is not None:
15779 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15780 
      oprot.writeI64(self.userId)
15781 
      oprot.writeFieldEnd()
15782 
    oprot.writeFieldStop()
15783 
    oprot.writeStructEnd()
15784 
 
15785 
  def validate(self):
15786 
    return
15787 
 
15788 
 
15789 
  def __repr__(self):
15790 
    L = ['%s=%r' % (key, value)
15791 
      for key, value in self.__dict__.iteritems()]
15792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15793 
 
15794 
  def __eq__(self, other):
15795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15796 
 
15797 
  def __ne__(self, other):
15798 
    return not (self == other)
15799 
 
15800 
class addPrivateDealUser_result:
15801 
  """
15802 
  Attributes:
15803 
   - success
15804 
  """
15805 
 
15806 
  thrift_spec = (
15807 
    (0, TType.BOOL, 'success', None, None, ), # 0
15808 
  )
15809 
 
15810 
  def __init__(self, success=None,):
15811 
    self.success = success
15812 
 
15813 
  def read(self, iprot):
15814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15816 
      return
15817 
    iprot.readStructBegin()
15818 
    while True:
15819 
      (fname, ftype, fid) = iprot.readFieldBegin()
15820 
      if ftype == TType.STOP:
15821 
        break
15822 
      if fid == 0:
15823 
        if ftype == TType.BOOL:
15824 
          self.success = iprot.readBool();
15825 
        else:
15826 
          iprot.skip(ftype)
15827 
      else:
15828 
        iprot.skip(ftype)
15829 
      iprot.readFieldEnd()
15830 
    iprot.readStructEnd()
15831 
 
15832 
  def write(self, oprot):
15833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15835 
      return
15836 
    oprot.writeStructBegin('addPrivateDealUser_result')
15837 
    if self.success is not None:
15838 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15839 
      oprot.writeBool(self.success)
15840 
      oprot.writeFieldEnd()
15841 
    oprot.writeFieldStop()
15842 
    oprot.writeStructEnd()
15843 
 
15844 
  def validate(self):
15845 
    return
15846 
 
15847 
 
15848 
  def __repr__(self):
15849 
    L = ['%s=%r' % (key, value)
15850 
      for key, value in self.__dict__.iteritems()]
15851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15852 
 
15853 
  def __eq__(self, other):
15854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15855 
 
15856 
  def __ne__(self, other):
15857 
    return not (self == other)
15858 
 
15859 
class changePrivateDealUserStatus_args:
15860 
  """
15861 
  Attributes:
15862 
   - userId
15863 
   - isActive
15864 
  """
15865 
 
15866 
  thrift_spec = (
15867 
    None, # 0
15868 
    (1, TType.I64, 'userId', None, None, ), # 1
15869 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15870 
  )
15871 
 
15872 
  def __init__(self, userId=None, isActive=None,):
15873 
    self.userId = userId
15874 
    self.isActive = isActive
15875 
 
15876 
  def read(self, iprot):
15877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15879 
      return
15880 
    iprot.readStructBegin()
15881 
    while True:
15882 
      (fname, ftype, fid) = iprot.readFieldBegin()
15883 
      if ftype == TType.STOP:
15884 
        break
15885 
      if fid == 1:
15886 
        if ftype == TType.I64:
15887 
          self.userId = iprot.readI64();
15888 
        else:
15889 
          iprot.skip(ftype)
15890 
      elif fid == 2:
15891 
        if ftype == TType.BOOL:
15892 
          self.isActive = iprot.readBool();
15893 
        else:
15894 
          iprot.skip(ftype)
15895 
      else:
15896 
        iprot.skip(ftype)
15897 
      iprot.readFieldEnd()
15898 
    iprot.readStructEnd()
15899 
 
15900 
  def write(self, oprot):
15901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15903 
      return
15904 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15905 
    if self.userId is not None:
15906 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15907 
      oprot.writeI64(self.userId)
15908 
      oprot.writeFieldEnd()
15909 
    if self.isActive is not None:
15910 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15911 
      oprot.writeBool(self.isActive)
15912 
      oprot.writeFieldEnd()
15913 
    oprot.writeFieldStop()
15914 
    oprot.writeStructEnd()
15915 
 
15916 
  def validate(self):
15917 
    return
15918 
 
15919 
 
15920 
  def __repr__(self):
15921 
    L = ['%s=%r' % (key, value)
15922 
      for key, value in self.__dict__.iteritems()]
15923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15924 
 
15925 
  def __eq__(self, other):
15926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15927 
 
15928 
  def __ne__(self, other):
15929 
    return not (self == other)
15930 
 
15931 
class changePrivateDealUserStatus_result:
15932 
  """
15933 
  Attributes:
15934 
   - success
15935 
  """
15936 
 
15937 
  thrift_spec = (
15938 
    (0, TType.BOOL, 'success', None, None, ), # 0
15939 
  )
15940 
 
15941 
  def __init__(self, success=None,):
15942 
    self.success = success
15943 
 
15944 
  def read(self, iprot):
15945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15947 
      return
15948 
    iprot.readStructBegin()
15949 
    while True:
15950 
      (fname, ftype, fid) = iprot.readFieldBegin()
15951 
      if ftype == TType.STOP:
15952 
        break
15953 
      if fid == 0:
15954 
        if ftype == TType.BOOL:
15955 
          self.success = iprot.readBool();
15956 
        else:
15957 
          iprot.skip(ftype)
15958 
      else:
15959 
        iprot.skip(ftype)
15960 
      iprot.readFieldEnd()
15961 
    iprot.readStructEnd()
15962 
 
15963 
  def write(self, oprot):
15964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15966 
      return
15967 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15968 
    if self.success is not None:
15969 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15970 
      oprot.writeBool(self.success)
15971 
      oprot.writeFieldEnd()
15972 
    oprot.writeFieldStop()
15973 
    oprot.writeStructEnd()
15974 
 
15975 
  def validate(self):
15976 
    return
15977 
 
15978 
 
15979 
  def __repr__(self):
15980 
    L = ['%s=%r' % (key, value)
15981 
      for key, value in self.__dict__.iteritems()]
15982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15983 
 
15984 
  def __eq__(self, other):
15985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15986 
 
15987 
  def __ne__(self, other):
15988 
    return not (self == other)
15989 
 
15990 
class getPrivateDealUser_args:
15991 
  """
15992 
  Attributes:
15993 
   - userId
15994 
  """
15995 
 
15996 
  thrift_spec = (
15997 
    None, # 0
15998 
    (1, TType.I64, 'userId', None, None, ), # 1
15999 
  )
16000 
 
16001 
  def __init__(self, userId=None,):
16002 
    self.userId = userId
16003 
 
16004 
  def read(self, iprot):
16005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16007 
      return
16008 
    iprot.readStructBegin()
16009 
    while True:
16010 
      (fname, ftype, fid) = iprot.readFieldBegin()
16011 
      if ftype == TType.STOP:
16012 
        break
16013 
      if fid == 1:
16014 
        if ftype == TType.I64:
16015 
          self.userId = iprot.readI64();
16016 
        else:
16017 
          iprot.skip(ftype)
16018 
      else:
16019 
        iprot.skip(ftype)
16020 
      iprot.readFieldEnd()
16021 
    iprot.readStructEnd()
16022 
 
16023 
  def write(self, oprot):
16024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16026 
      return
16027 
    oprot.writeStructBegin('getPrivateDealUser_args')
16028 
    if self.userId is not None:
16029 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16030 
      oprot.writeI64(self.userId)
16031 
      oprot.writeFieldEnd()
16032 
    oprot.writeFieldStop()
16033 
    oprot.writeStructEnd()
16034 
 
16035 
  def validate(self):
16036 
    return
16037 
 
16038 
 
16039 
  def __repr__(self):
16040 
    L = ['%s=%r' % (key, value)
16041 
      for key, value in self.__dict__.iteritems()]
16042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16043 
 
16044 
  def __eq__(self, other):
16045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16046 
 
16047 
  def __ne__(self, other):
16048 
    return not (self == other)
16049 
 
16050 
class getPrivateDealUser_result:
16051 
  """
16052 
  Attributes:
16053 
   - success
16054 
  """
16055 
 
16056 
  thrift_spec = (
16057 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
16058 
  )
16059 
 
16060 
  def __init__(self, success=None,):
16061 
    self.success = success
16062 
 
16063 
  def read(self, iprot):
16064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16066 
      return
16067 
    iprot.readStructBegin()
16068 
    while True:
16069 
      (fname, ftype, fid) = iprot.readFieldBegin()
16070 
      if ftype == TType.STOP:
16071 
        break
16072 
      if fid == 0:
16073 
        if ftype == TType.STRUCT:
16074 
          self.success = PrivateDealUser()
16075 
          self.success.read(iprot)
16076 
        else:
16077 
          iprot.skip(ftype)
16078 
      else:
16079 
        iprot.skip(ftype)
16080 
      iprot.readFieldEnd()
16081 
    iprot.readStructEnd()
16082 
 
16083 
  def write(self, oprot):
16084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16086 
      return
16087 
    oprot.writeStructBegin('getPrivateDealUser_result')
16088 
    if self.success is not None:
16089 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16090 
      self.success.write(oprot)
16091 
      oprot.writeFieldEnd()
16092 
    oprot.writeFieldStop()
16093 
    oprot.writeStructEnd()
16094 
 
16095 
  def validate(self):
16096 
    return
16097 
 
16098 
 
16099 
  def __repr__(self):
16100 
    L = ['%s=%r' % (key, value)
16101 
      for key, value in self.__dict__.iteritems()]
16102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16103 
 
16104 
  def __eq__(self, other):
16105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16106 
 
16107 
  def __ne__(self, other):
16108 
    return not (self == other)
12696 amit.gupta 16109 
 
16110 
class registerCounter_args:
16111 
  """
16112 
  Attributes:
16113 
   - counter
16114 
   - userId
16115 
  """
16116 
 
16117 
  thrift_spec = (
16118 
    None, # 0
16119 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16120 
    (2, TType.I64, 'userId', None, None, ), # 2
16121 
  )
16122 
 
16123 
  def __init__(self, counter=None, userId=None,):
16124 
    self.counter = counter
16125 
    self.userId = userId
16126 
 
16127 
  def read(self, iprot):
16128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16130 
      return
16131 
    iprot.readStructBegin()
16132 
    while True:
16133 
      (fname, ftype, fid) = iprot.readFieldBegin()
16134 
      if ftype == TType.STOP:
16135 
        break
16136 
      if fid == 1:
16137 
        if ftype == TType.STRUCT:
16138 
          self.counter = Counter()
16139 
          self.counter.read(iprot)
16140 
        else:
16141 
          iprot.skip(ftype)
16142 
      elif fid == 2:
16143 
        if ftype == TType.I64:
16144 
          self.userId = iprot.readI64();
16145 
        else:
16146 
          iprot.skip(ftype)
16147 
      else:
16148 
        iprot.skip(ftype)
16149 
      iprot.readFieldEnd()
16150 
    iprot.readStructEnd()
16151 
 
16152 
  def write(self, oprot):
16153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16155 
      return
16156 
    oprot.writeStructBegin('registerCounter_args')
16157 
    if self.counter is not None:
16158 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16159 
      self.counter.write(oprot)
16160 
      oprot.writeFieldEnd()
16161 
    if self.userId is not None:
16162 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16163 
      oprot.writeI64(self.userId)
16164 
      oprot.writeFieldEnd()
16165 
    oprot.writeFieldStop()
16166 
    oprot.writeStructEnd()
16167 
 
16168 
  def validate(self):
16169 
    return
16170 
 
16171 
 
16172 
  def __repr__(self):
16173 
    L = ['%s=%r' % (key, value)
16174 
      for key, value in self.__dict__.iteritems()]
16175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16176 
 
16177 
  def __eq__(self, other):
16178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16179 
 
16180 
  def __ne__(self, other):
16181 
    return not (self == other)
16182 
 
16183 
class registerCounter_result:
16184 
  """
16185 
  Attributes:
16186 
   - success
16187 
  """
16188 
 
16189 
  thrift_spec = (
16190 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16191 
  )
16192 
 
16193 
  def __init__(self, success=None,):
16194 
    self.success = success
16195 
 
16196 
  def read(self, iprot):
16197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16199 
      return
16200 
    iprot.readStructBegin()
16201 
    while True:
16202 
      (fname, ftype, fid) = iprot.readFieldBegin()
16203 
      if ftype == TType.STOP:
16204 
        break
16205 
      if fid == 0:
16206 
        if ftype == TType.MAP:
16207 
          self.success = {}
16208 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16209 
          for _i229 in xrange(_size225):
16210 
            _key230 = iprot.readString();
16211 
            _val231 = iprot.readString();
16212 
            self.success[_key230] = _val231
16213 
          iprot.readMapEnd()
16214 
        else:
16215 
          iprot.skip(ftype)
16216 
      else:
16217 
        iprot.skip(ftype)
16218 
      iprot.readFieldEnd()
16219 
    iprot.readStructEnd()
16220 
 
16221 
  def write(self, oprot):
16222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16224 
      return
16225 
    oprot.writeStructBegin('registerCounter_result')
16226 
    if self.success is not None:
16227 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16228 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16229 
      for kiter232,viter233 in self.success.items():
16230 
        oprot.writeString(kiter232)
16231 
        oprot.writeString(viter233)
16232 
      oprot.writeMapEnd()
16233 
      oprot.writeFieldEnd()
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
12722 amit.gupta 16251 
 
16252 
class searchCounter_args:
16253 
  """
16254 
  Attributes:
16255 
   - type1
16256 
   - searchString
16257 
  """
16258 
 
16259 
  thrift_spec = (
16260 
    None, # 0
16261 
    (1, TType.STRING, 'type1', None, None, ), # 1
16262 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16263 
  )
16264 
 
16265 
  def __init__(self, type1=None, searchString=None,):
16266 
    self.type1 = type1
16267 
    self.searchString = searchString
16268 
 
16269 
  def read(self, iprot):
16270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16272 
      return
16273 
    iprot.readStructBegin()
16274 
    while True:
16275 
      (fname, ftype, fid) = iprot.readFieldBegin()
16276 
      if ftype == TType.STOP:
16277 
        break
16278 
      if fid == 1:
16279 
        if ftype == TType.STRING:
16280 
          self.type1 = iprot.readString();
16281 
        else:
16282 
          iprot.skip(ftype)
16283 
      elif fid == 2:
16284 
        if ftype == TType.STRING:
16285 
          self.searchString = iprot.readString();
16286 
        else:
16287 
          iprot.skip(ftype)
16288 
      else:
16289 
        iprot.skip(ftype)
16290 
      iprot.readFieldEnd()
16291 
    iprot.readStructEnd()
16292 
 
16293 
  def write(self, oprot):
16294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16296 
      return
16297 
    oprot.writeStructBegin('searchCounter_args')
16298 
    if self.type1 is not None:
16299 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16300 
      oprot.writeString(self.type1)
16301 
      oprot.writeFieldEnd()
16302 
    if self.searchString is not None:
16303 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16304 
      oprot.writeString(self.searchString)
16305 
      oprot.writeFieldEnd()
16306 
    oprot.writeFieldStop()
16307 
    oprot.writeStructEnd()
16308 
 
16309 
  def validate(self):
16310 
    return
16311 
 
16312 
 
16313 
  def __repr__(self):
16314 
    L = ['%s=%r' % (key, value)
16315 
      for key, value in self.__dict__.iteritems()]
16316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16317 
 
16318 
  def __eq__(self, other):
16319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16320 
 
16321 
  def __ne__(self, other):
16322 
    return not (self == other)
16323 
 
16324 
class searchCounter_result:
16325 
  """
16326 
  Attributes:
16327 
   - success
16328 
  """
16329 
 
16330 
  thrift_spec = (
16331 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16332 
  )
16333 
 
16334 
  def __init__(self, success=None,):
16335 
    self.success = success
16336 
 
16337 
  def read(self, iprot):
16338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16340 
      return
16341 
    iprot.readStructBegin()
16342 
    while True:
16343 
      (fname, ftype, fid) = iprot.readFieldBegin()
16344 
      if ftype == TType.STOP:
16345 
        break
16346 
      if fid == 0:
16347 
        if ftype == TType.LIST:
16348 
          self.success = []
16349 
          (_etype237, _size234) = iprot.readListBegin()
16350 
          for _i238 in xrange(_size234):
16351 
            _elem239 = Counter()
16352 
            _elem239.read(iprot)
16353 
            self.success.append(_elem239)
16354 
          iprot.readListEnd()
16355 
        else:
16356 
          iprot.skip(ftype)
16357 
      else:
16358 
        iprot.skip(ftype)
16359 
      iprot.readFieldEnd()
16360 
    iprot.readStructEnd()
16361 
 
16362 
  def write(self, oprot):
16363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16365 
      return
16366 
    oprot.writeStructBegin('searchCounter_result')
16367 
    if self.success is not None:
16368 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16369 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16370 
      for iter240 in self.success:
16371 
        iter240.write(oprot)
16372 
      oprot.writeListEnd()
16373 
      oprot.writeFieldEnd()
16374 
    oprot.writeFieldStop()
16375 
    oprot.writeStructEnd()
16376 
 
16377 
  def validate(self):
16378 
    return
16379 
 
16380 
 
16381 
  def __repr__(self):
16382 
    L = ['%s=%r' % (key, value)
16383 
      for key, value in self.__dict__.iteritems()]
16384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16385 
 
16386 
  def __eq__(self, other):
16387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16388 
 
16389 
  def __ne__(self, other):
16390 
    return not (self == other)
16391 
 
18977 amit.gupta 16392 
class getCounterByUserId_args:
16393 
  """
16394 
  Attributes:
16395 
   - userId
16396 
  """
16397 
 
16398 
  thrift_spec = (
16399 
    None, # 0
16400 
    (1, TType.I64, 'userId', None, None, ), # 1
16401 
  )
16402 
 
16403 
  def __init__(self, userId=None,):
16404 
    self.userId = userId
16405 
 
16406 
  def read(self, iprot):
16407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16409 
      return
16410 
    iprot.readStructBegin()
16411 
    while True:
16412 
      (fname, ftype, fid) = iprot.readFieldBegin()
16413 
      if ftype == TType.STOP:
16414 
        break
16415 
      if fid == 1:
16416 
        if ftype == TType.I64:
16417 
          self.userId = iprot.readI64();
16418 
        else:
16419 
          iprot.skip(ftype)
16420 
      else:
16421 
        iprot.skip(ftype)
16422 
      iprot.readFieldEnd()
16423 
    iprot.readStructEnd()
16424 
 
16425 
  def write(self, oprot):
16426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16428 
      return
16429 
    oprot.writeStructBegin('getCounterByUserId_args')
16430 
    if self.userId is not None:
16431 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16432 
      oprot.writeI64(self.userId)
16433 
      oprot.writeFieldEnd()
16434 
    oprot.writeFieldStop()
16435 
    oprot.writeStructEnd()
16436 
 
16437 
  def validate(self):
16438 
    return
16439 
 
16440 
 
16441 
  def __repr__(self):
16442 
    L = ['%s=%r' % (key, value)
16443 
      for key, value in self.__dict__.iteritems()]
16444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16445 
 
16446 
  def __eq__(self, other):
16447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16448 
 
16449 
  def __ne__(self, other):
16450 
    return not (self == other)
16451 
 
16452 
class getCounterByUserId_result:
16453 
  """
16454 
  Attributes:
16455 
   - success
16456 
  """
16457 
 
16458 
  thrift_spec = (
16459 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16460 
  )
16461 
 
16462 
  def __init__(self, success=None,):
16463 
    self.success = success
16464 
 
16465 
  def read(self, iprot):
16466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16468 
      return
16469 
    iprot.readStructBegin()
16470 
    while True:
16471 
      (fname, ftype, fid) = iprot.readFieldBegin()
16472 
      if ftype == TType.STOP:
16473 
        break
16474 
      if fid == 0:
16475 
        if ftype == TType.STRUCT:
16476 
          self.success = Counter()
16477 
          self.success.read(iprot)
16478 
        else:
16479 
          iprot.skip(ftype)
16480 
      else:
16481 
        iprot.skip(ftype)
16482 
      iprot.readFieldEnd()
16483 
    iprot.readStructEnd()
16484 
 
16485 
  def write(self, oprot):
16486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16488 
      return
16489 
    oprot.writeStructBegin('getCounterByUserId_result')
16490 
    if self.success is not None:
16491 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16492 
      self.success.write(oprot)
16493 
      oprot.writeFieldEnd()
16494 
    oprot.writeFieldStop()
16495 
    oprot.writeStructEnd()
16496 
 
16497 
  def validate(self):
16498 
    return
16499 
 
16500 
 
16501 
  def __repr__(self):
16502 
    L = ['%s=%r' % (key, value)
16503 
      for key, value in self.__dict__.iteritems()]
16504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16505 
 
16506 
  def __eq__(self, other):
16507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16508 
 
16509 
  def __ne__(self, other):
16510 
    return not (self == other)
16511 
 
12722 amit.gupta 16512 
class getAllUsersByCounter_args:
16513 
  """
16514 
  Attributes:
16515 
   - counterId
16516 
  """
16517 
 
16518 
  thrift_spec = (
16519 
    None, # 0
16520 
    (1, TType.I64, 'counterId', None, None, ), # 1
16521 
  )
16522 
 
16523 
  def __init__(self, counterId=None,):
16524 
    self.counterId = counterId
16525 
 
16526 
  def read(self, iprot):
16527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16529 
      return
16530 
    iprot.readStructBegin()
16531 
    while True:
16532 
      (fname, ftype, fid) = iprot.readFieldBegin()
16533 
      if ftype == TType.STOP:
16534 
        break
16535 
      if fid == 1:
16536 
        if ftype == TType.I64:
16537 
          self.counterId = iprot.readI64();
16538 
        else:
16539 
          iprot.skip(ftype)
16540 
      else:
16541 
        iprot.skip(ftype)
16542 
      iprot.readFieldEnd()
16543 
    iprot.readStructEnd()
16544 
 
16545 
  def write(self, oprot):
16546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16548 
      return
16549 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16550 
    if self.counterId is not None:
16551 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16552 
      oprot.writeI64(self.counterId)
16553 
      oprot.writeFieldEnd()
16554 
    oprot.writeFieldStop()
16555 
    oprot.writeStructEnd()
16556 
 
16557 
  def validate(self):
16558 
    return
16559 
 
16560 
 
16561 
  def __repr__(self):
16562 
    L = ['%s=%r' % (key, value)
16563 
      for key, value in self.__dict__.iteritems()]
16564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16565 
 
16566 
  def __eq__(self, other):
16567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16568 
 
16569 
  def __ne__(self, other):
16570 
    return not (self == other)
16571 
 
16572 
class getAllUsersByCounter_result:
16573 
  """
16574 
  Attributes:
16575 
   - success
16576 
  """
16577 
 
16578 
  thrift_spec = (
16579 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16580 
  )
16581 
 
16582 
  def __init__(self, success=None,):
16583 
    self.success = success
16584 
 
16585 
  def read(self, iprot):
16586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16588 
      return
16589 
    iprot.readStructBegin()
16590 
    while True:
16591 
      (fname, ftype, fid) = iprot.readFieldBegin()
16592 
      if ftype == TType.STOP:
16593 
        break
16594 
      if fid == 0:
16595 
        if ftype == TType.LIST:
16596 
          self.success = []
16597 
          (_etype244, _size241) = iprot.readListBegin()
16598 
          for _i245 in xrange(_size241):
16599 
            _elem246 = User()
16600 
            _elem246.read(iprot)
16601 
            self.success.append(_elem246)
16602 
          iprot.readListEnd()
16603 
        else:
16604 
          iprot.skip(ftype)
16605 
      else:
16606 
        iprot.skip(ftype)
16607 
      iprot.readFieldEnd()
16608 
    iprot.readStructEnd()
16609 
 
16610 
  def write(self, oprot):
16611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16613 
      return
16614 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16615 
    if self.success is not None:
16616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16618 
      for iter247 in self.success:
16619 
        iter247.write(oprot)
16620 
      oprot.writeListEnd()
16621 
      oprot.writeFieldEnd()
16622 
    oprot.writeFieldStop()
16623 
    oprot.writeStructEnd()
16624 
 
16625 
  def validate(self):
16626 
    return
16627 
 
16628 
 
16629 
  def __repr__(self):
16630 
    L = ['%s=%r' % (key, value)
16631 
      for key, value in self.__dict__.iteritems()]
16632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16633 
 
16634 
  def __eq__(self, other):
16635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16636 
 
16637 
  def __ne__(self, other):
16638 
    return not (self == other)
15251 manish.sha 16639 
 
16640 
class getActiveAccessTokenForUser_args:
16641 
  """
16642 
  Attributes:
16643 
   - userId
16644 
   - source
16645 
  """
16646 
 
16647 
  thrift_spec = (
16648 
    None, # 0
16649 
    (1, TType.I64, 'userId', None, None, ), # 1
16650 
    (2, TType.STRING, 'source', None, None, ), # 2
16651 
  )
16652 
 
16653 
  def __init__(self, userId=None, source=None,):
16654 
    self.userId = userId
16655 
    self.source = source
16656 
 
16657 
  def read(self, iprot):
16658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16660 
      return
16661 
    iprot.readStructBegin()
16662 
    while True:
16663 
      (fname, ftype, fid) = iprot.readFieldBegin()
16664 
      if ftype == TType.STOP:
16665 
        break
16666 
      if fid == 1:
16667 
        if ftype == TType.I64:
16668 
          self.userId = iprot.readI64();
16669 
        else:
16670 
          iprot.skip(ftype)
16671 
      elif fid == 2:
16672 
        if ftype == TType.STRING:
16673 
          self.source = iprot.readString();
16674 
        else:
16675 
          iprot.skip(ftype)
16676 
      else:
16677 
        iprot.skip(ftype)
16678 
      iprot.readFieldEnd()
16679 
    iprot.readStructEnd()
16680 
 
16681 
  def write(self, oprot):
16682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16684 
      return
16685 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16686 
    if self.userId is not None:
16687 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16688 
      oprot.writeI64(self.userId)
16689 
      oprot.writeFieldEnd()
16690 
    if self.source is not None:
16691 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16692 
      oprot.writeString(self.source)
16693 
      oprot.writeFieldEnd()
16694 
    oprot.writeFieldStop()
16695 
    oprot.writeStructEnd()
16696 
 
16697 
  def validate(self):
16698 
    return
16699 
 
16700 
 
16701 
  def __repr__(self):
16702 
    L = ['%s=%r' % (key, value)
16703 
      for key, value in self.__dict__.iteritems()]
16704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16705 
 
16706 
  def __eq__(self, other):
16707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16708 
 
16709 
  def __ne__(self, other):
16710 
    return not (self == other)
16711 
 
16712 
class getActiveAccessTokenForUser_result:
16713 
  """
16714 
  Attributes:
16715 
   - success
16716 
  """
16717 
 
16718 
  thrift_spec = (
16719 
    (0, TType.STRING, 'success', None, None, ), # 0
16720 
  )
16721 
 
16722 
  def __init__(self, success=None,):
16723 
    self.success = success
16724 
 
16725 
  def read(self, iprot):
16726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16728 
      return
16729 
    iprot.readStructBegin()
16730 
    while True:
16731 
      (fname, ftype, fid) = iprot.readFieldBegin()
16732 
      if ftype == TType.STOP:
16733 
        break
16734 
      if fid == 0:
16735 
        if ftype == TType.STRING:
16736 
          self.success = iprot.readString();
16737 
        else:
16738 
          iprot.skip(ftype)
16739 
      else:
16740 
        iprot.skip(ftype)
16741 
      iprot.readFieldEnd()
16742 
    iprot.readStructEnd()
16743 
 
16744 
  def write(self, oprot):
16745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16747 
      return
16748 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16749 
    if self.success is not None:
16750 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16751 
      oprot.writeString(self.success)
16752 
      oprot.writeFieldEnd()
16753 
    oprot.writeFieldStop()
16754 
    oprot.writeStructEnd()
16755 
 
16756 
  def validate(self):
16757 
    return
16758 
 
16759 
 
16760 
  def __repr__(self):
16761 
    L = ['%s=%r' % (key, value)
16762 
      for key, value in self.__dict__.iteritems()]
16763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16764 
 
16765 
  def __eq__(self, other):
16766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16767 
 
16768 
  def __ne__(self, other):
16769 
    return not (self == other)
16770 
 
16771 
class validateAccessToken_args:
16772 
  """
16773 
  Attributes:
16774 
   - accessToken
16775 
  """
16776 
 
16777 
  thrift_spec = (
16778 
    None, # 0
16779 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16780 
  )
16781 
 
16782 
  def __init__(self, accessToken=None,):
16783 
    self.accessToken = accessToken
16784 
 
16785 
  def read(self, iprot):
16786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16788 
      return
16789 
    iprot.readStructBegin()
16790 
    while True:
16791 
      (fname, ftype, fid) = iprot.readFieldBegin()
16792 
      if ftype == TType.STOP:
16793 
        break
16794 
      if fid == 1:
16795 
        if ftype == TType.STRING:
16796 
          self.accessToken = iprot.readString();
16797 
        else:
16798 
          iprot.skip(ftype)
16799 
      else:
16800 
        iprot.skip(ftype)
16801 
      iprot.readFieldEnd()
16802 
    iprot.readStructEnd()
16803 
 
16804 
  def write(self, oprot):
16805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16807 
      return
16808 
    oprot.writeStructBegin('validateAccessToken_args')
16809 
    if self.accessToken is not None:
16810 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16811 
      oprot.writeString(self.accessToken)
16812 
      oprot.writeFieldEnd()
16813 
    oprot.writeFieldStop()
16814 
    oprot.writeStructEnd()
16815 
 
16816 
  def validate(self):
16817 
    return
16818 
 
16819 
 
16820 
  def __repr__(self):
16821 
    L = ['%s=%r' % (key, value)
16822 
      for key, value in self.__dict__.iteritems()]
16823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16824 
 
16825 
  def __eq__(self, other):
16826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16827 
 
16828 
  def __ne__(self, other):
16829 
    return not (self == other)
16830 
 
16831 
class validateAccessToken_result:
16832 
  """
16833 
  Attributes:
16834 
   - success
16835 
  """
16836 
 
16837 
  thrift_spec = (
16838 
    (0, TType.BOOL, 'success', None, None, ), # 0
16839 
  )
16840 
 
16841 
  def __init__(self, success=None,):
16842 
    self.success = success
16843 
 
16844 
  def read(self, iprot):
16845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16847 
      return
16848 
    iprot.readStructBegin()
16849 
    while True:
16850 
      (fname, ftype, fid) = iprot.readFieldBegin()
16851 
      if ftype == TType.STOP:
16852 
        break
16853 
      if fid == 0:
16854 
        if ftype == TType.BOOL:
16855 
          self.success = iprot.readBool();
16856 
        else:
16857 
          iprot.skip(ftype)
16858 
      else:
16859 
        iprot.skip(ftype)
16860 
      iprot.readFieldEnd()
16861 
    iprot.readStructEnd()
16862 
 
16863 
  def write(self, oprot):
16864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16866 
      return
16867 
    oprot.writeStructBegin('validateAccessToken_result')
16868 
    if self.success is not None:
16869 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16870 
      oprot.writeBool(self.success)
16871 
      oprot.writeFieldEnd()
16872 
    oprot.writeFieldStop()
16873 
    oprot.writeStructEnd()
16874 
 
16875 
  def validate(self):
16876 
    return
16877 
 
16878 
 
16879 
  def __repr__(self):
16880 
    L = ['%s=%r' % (key, value)
16881 
      for key, value in self.__dict__.iteritems()]
16882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16883 
 
16884 
  def __eq__(self, other):
16885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16886 
 
16887 
  def __ne__(self, other):
16888 
    return not (self == other)
17782 amit.gupta 16889 
 
16890 
class addItemsToCart_args:
16891 
  """
16892 
  Attributes:
16893 
   - cartId
16894 
   - itemQty
16895 
   - couponCode
16896 
  """
16897 
 
16898 
  thrift_spec = (
16899 
    None, # 0
16900 
    (1, TType.I64, 'cartId', None, None, ), # 1
16901 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16902 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16903 
  )
16904 
 
16905 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16906 
    self.cartId = cartId
16907 
    self.itemQty = itemQty
16908 
    self.couponCode = couponCode
16909 
 
16910 
  def read(self, iprot):
16911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16913 
      return
16914 
    iprot.readStructBegin()
16915 
    while True:
16916 
      (fname, ftype, fid) = iprot.readFieldBegin()
16917 
      if ftype == TType.STOP:
16918 
        break
16919 
      if fid == 1:
16920 
        if ftype == TType.I64:
16921 
          self.cartId = iprot.readI64();
16922 
        else:
16923 
          iprot.skip(ftype)
16924 
      elif fid == 2:
16925 
        if ftype == TType.LIST:
16926 
          self.itemQty = []
16927 
          (_etype251, _size248) = iprot.readListBegin()
16928 
          for _i252 in xrange(_size248):
16929 
            _elem253 = ItemQuantity()
16930 
            _elem253.read(iprot)
16931 
            self.itemQty.append(_elem253)
16932 
          iprot.readListEnd()
16933 
        else:
16934 
          iprot.skip(ftype)
16935 
      elif fid == 3:
16936 
        if ftype == TType.STRING:
16937 
          self.couponCode = iprot.readString();
16938 
        else:
16939 
          iprot.skip(ftype)
16940 
      else:
16941 
        iprot.skip(ftype)
16942 
      iprot.readFieldEnd()
16943 
    iprot.readStructEnd()
16944 
 
16945 
  def write(self, oprot):
16946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16948 
      return
16949 
    oprot.writeStructBegin('addItemsToCart_args')
16950 
    if self.cartId is not None:
16951 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16952 
      oprot.writeI64(self.cartId)
16953 
      oprot.writeFieldEnd()
16954 
    if self.itemQty is not None:
16955 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16956 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16957 
      for iter254 in self.itemQty:
16958 
        iter254.write(oprot)
16959 
      oprot.writeListEnd()
16960 
      oprot.writeFieldEnd()
16961 
    if self.couponCode is not None:
16962 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16963 
      oprot.writeString(self.couponCode)
16964 
      oprot.writeFieldEnd()
16965 
    oprot.writeFieldStop()
16966 
    oprot.writeStructEnd()
16967 
 
16968 
  def validate(self):
16969 
    return
16970 
 
16971 
 
16972 
  def __repr__(self):
16973 
    L = ['%s=%r' % (key, value)
16974 
      for key, value in self.__dict__.iteritems()]
16975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16976 
 
16977 
  def __eq__(self, other):
16978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16979 
 
16980 
  def __ne__(self, other):
16981 
    return not (self == other)
16982 
 
16983 
class addItemsToCart_result:
16984 
  """
16985 
  Attributes:
16986 
   - success
16987 
  """
16988 
 
16989 
  thrift_spec = (
16990 
    (0, TType.BOOL, 'success', None, None, ), # 0
16991 
  )
16992 
 
16993 
  def __init__(self, success=None,):
16994 
    self.success = success
16995 
 
16996 
  def read(self, iprot):
16997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16999 
      return
17000 
    iprot.readStructBegin()
17001 
    while True:
17002 
      (fname, ftype, fid) = iprot.readFieldBegin()
17003 
      if ftype == TType.STOP:
17004 
        break
17005 
      if fid == 0:
17006 
        if ftype == TType.BOOL:
17007 
          self.success = iprot.readBool();
17008 
        else:
17009 
          iprot.skip(ftype)
17010 
      else:
17011 
        iprot.skip(ftype)
17012 
      iprot.readFieldEnd()
17013 
    iprot.readStructEnd()
17014 
 
17015 
  def write(self, oprot):
17016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17018 
      return
17019 
    oprot.writeStructBegin('addItemsToCart_result')
17020 
    if self.success is not None:
17021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17022 
      oprot.writeBool(self.success)
17023 
      oprot.writeFieldEnd()
17024 
    oprot.writeFieldStop()
17025 
    oprot.writeStructEnd()
17026 
 
17027 
  def validate(self):
17028 
    return
17029 
 
17030 
 
17031 
  def __repr__(self):
17032 
    L = ['%s=%r' % (key, value)
17033 
      for key, value in self.__dict__.iteritems()]
17034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17035 
 
17036 
  def __eq__(self, other):
17037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17038 
 
17039 
  def __ne__(self, other):
17040 
    return not (self == other)
17041 
 
17042 
class validateCartNew_args:
17043 
  """
17044 
  Attributes:
17045 
   - cartId
17046 
   - pinCode
17047 
   - sourceId
17048 
  """
17049 
 
17050 
  thrift_spec = (
17051 
    None, # 0
17052 
    (1, TType.I64, 'cartId', None, None, ), # 1
17053 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
17054 
    (3, TType.I64, 'sourceId', None, None, ), # 3
17055 
  )
17056 
 
17057 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
17058 
    self.cartId = cartId
17059 
    self.pinCode = pinCode
17060 
    self.sourceId = sourceId
17061 
 
17062 
  def read(self, iprot):
17063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17065 
      return
17066 
    iprot.readStructBegin()
17067 
    while True:
17068 
      (fname, ftype, fid) = iprot.readFieldBegin()
17069 
      if ftype == TType.STOP:
17070 
        break
17071 
      if fid == 1:
17072 
        if ftype == TType.I64:
17073 
          self.cartId = iprot.readI64();
17074 
        else:
17075 
          iprot.skip(ftype)
17076 
      elif fid == 2:
17077 
        if ftype == TType.STRING:
17078 
          self.pinCode = iprot.readString();
17079 
        else:
17080 
          iprot.skip(ftype)
17081 
      elif fid == 3:
17082 
        if ftype == TType.I64:
17083 
          self.sourceId = iprot.readI64();
17084 
        else:
17085 
          iprot.skip(ftype)
17086 
      else:
17087 
        iprot.skip(ftype)
17088 
      iprot.readFieldEnd()
17089 
    iprot.readStructEnd()
17090 
 
17091 
  def write(self, oprot):
17092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17094 
      return
17095 
    oprot.writeStructBegin('validateCartNew_args')
17096 
    if self.cartId is not None:
17097 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
17098 
      oprot.writeI64(self.cartId)
17099 
      oprot.writeFieldEnd()
17100 
    if self.pinCode is not None:
17101 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17102 
      oprot.writeString(self.pinCode)
17103 
      oprot.writeFieldEnd()
17104 
    if self.sourceId is not None:
17105 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17106 
      oprot.writeI64(self.sourceId)
17107 
      oprot.writeFieldEnd()
17108 
    oprot.writeFieldStop()
17109 
    oprot.writeStructEnd()
17110 
 
17111 
  def validate(self):
17112 
    return
17113 
 
17114 
 
17115 
  def __repr__(self):
17116 
    L = ['%s=%r' % (key, value)
17117 
      for key, value in self.__dict__.iteritems()]
17118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17119 
 
17120 
  def __eq__(self, other):
17121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17122 
 
17123 
  def __ne__(self, other):
17124 
    return not (self == other)
17125 
 
17126 
class validateCartNew_result:
17127 
  """
17128 
  Attributes:
17129 
   - success
17130 
  """
17131 
 
17132 
  thrift_spec = (
17133 
    (0, TType.STRING, 'success', None, None, ), # 0
17134 
  )
17135 
 
17136 
  def __init__(self, success=None,):
17137 
    self.success = success
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      if fid == 0:
17149 
        if ftype == TType.STRING:
17150 
          self.success = iprot.readString();
17151 
        else:
17152 
          iprot.skip(ftype)
17153 
      else:
17154 
        iprot.skip(ftype)
17155 
      iprot.readFieldEnd()
17156 
    iprot.readStructEnd()
17157 
 
17158 
  def write(self, oprot):
17159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17161 
      return
17162 
    oprot.writeStructBegin('validateCartNew_result')
17163 
    if self.success is not None:
17164 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17165 
      oprot.writeString(self.success)
17166 
      oprot.writeFieldEnd()
17167 
    oprot.writeFieldStop()
17168 
    oprot.writeStructEnd()
17169 
 
17170 
  def validate(self):
17171 
    return
17172 
 
17173 
 
17174 
  def __repr__(self):
17175 
    L = ['%s=%r' % (key, value)
17176 
      for key, value in self.__dict__.iteritems()]
17177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17178 
 
17179 
  def __eq__(self, other):
17180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17181 
 
17182 
  def __ne__(self, other):
17183 
    return not (self == other)
18530 manish.sha 17184 
 
18644 manish.sha 17185 
class isAddressEditableForCounter_args:
18530 manish.sha 17186 
  """
17187 
  Attributes:
17188 
   - userId
17189 
  """
17190 
 
17191 
  thrift_spec = (
17192 
    None, # 0
17193 
    (1, TType.I64, 'userId', None, None, ), # 1
17194 
  )
17195 
 
17196 
  def __init__(self, userId=None,):
17197 
    self.userId = userId
17198 
 
17199 
  def read(self, iprot):
17200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17202 
      return
17203 
    iprot.readStructBegin()
17204 
    while True:
17205 
      (fname, ftype, fid) = iprot.readFieldBegin()
17206 
      if ftype == TType.STOP:
17207 
        break
17208 
      if fid == 1:
17209 
        if ftype == TType.I64:
17210 
          self.userId = iprot.readI64();
17211 
        else:
17212 
          iprot.skip(ftype)
17213 
      else:
17214 
        iprot.skip(ftype)
17215 
      iprot.readFieldEnd()
17216 
    iprot.readStructEnd()
17217 
 
17218 
  def write(self, oprot):
17219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17221 
      return
18644 manish.sha 17222 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17223 
    if self.userId is not None:
17224 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17225 
      oprot.writeI64(self.userId)
17226 
      oprot.writeFieldEnd()
17227 
    oprot.writeFieldStop()
17228 
    oprot.writeStructEnd()
17229 
 
17230 
  def validate(self):
17231 
    return
17232 
 
17233 
 
17234 
  def __repr__(self):
17235 
    L = ['%s=%r' % (key, value)
17236 
      for key, value in self.__dict__.iteritems()]
17237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17238 
 
17239 
  def __eq__(self, other):
17240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17241 
 
17242 
  def __ne__(self, other):
17243 
    return not (self == other)
17244 
 
18644 manish.sha 17245 
class isAddressEditableForCounter_result:
18530 manish.sha 17246 
  """
17247 
  Attributes:
17248 
   - success
17249 
  """
17250 
 
17251 
  thrift_spec = (
17252 
    (0, TType.BOOL, 'success', None, None, ), # 0
17253 
  )
17254 
 
17255 
  def __init__(self, success=None,):
17256 
    self.success = success
17257 
 
17258 
  def read(self, iprot):
17259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17261 
      return
17262 
    iprot.readStructBegin()
17263 
    while True:
17264 
      (fname, ftype, fid) = iprot.readFieldBegin()
17265 
      if ftype == TType.STOP:
17266 
        break
17267 
      if fid == 0:
17268 
        if ftype == TType.BOOL:
17269 
          self.success = iprot.readBool();
17270 
        else:
17271 
          iprot.skip(ftype)
17272 
      else:
17273 
        iprot.skip(ftype)
17274 
      iprot.readFieldEnd()
17275 
    iprot.readStructEnd()
17276 
 
17277 
  def write(self, oprot):
17278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17280 
      return
18644 manish.sha 17281 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17282 
    if self.success is not None:
17283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17284 
      oprot.writeBool(self.success)
17285 
      oprot.writeFieldEnd()
17286 
    oprot.writeFieldStop()
17287 
    oprot.writeStructEnd()
17288 
 
17289 
  def validate(self):
17290 
    return
17291 
 
17292 
 
17293 
  def __repr__(self):
17294 
    L = ['%s=%r' % (key, value)
17295 
      for key, value in self.__dict__.iteritems()]
17296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17297 
 
17298 
  def __eq__(self, other):
17299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17300 
 
17301 
  def __ne__(self, other):
17302 
    return not (self == other)
17303 
 
17304 
class getBillingAddressForUser_args:
17305 
  """
17306 
  Attributes:
17307 
   - userId
17308 
  """
17309 
 
17310 
  thrift_spec = (
17311 
    None, # 0
17312 
    (1, TType.I64, 'userId', None, None, ), # 1
17313 
  )
17314 
 
17315 
  def __init__(self, userId=None,):
17316 
    self.userId = userId
17317 
 
17318 
  def read(self, iprot):
17319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17321 
      return
17322 
    iprot.readStructBegin()
17323 
    while True:
17324 
      (fname, ftype, fid) = iprot.readFieldBegin()
17325 
      if ftype == TType.STOP:
17326 
        break
17327 
      if fid == 1:
17328 
        if ftype == TType.I64:
17329 
          self.userId = iprot.readI64();
17330 
        else:
17331 
          iprot.skip(ftype)
17332 
      else:
17333 
        iprot.skip(ftype)
17334 
      iprot.readFieldEnd()
17335 
    iprot.readStructEnd()
17336 
 
17337 
  def write(self, oprot):
17338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17340 
      return
17341 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17342 
    if self.userId is not None:
17343 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17344 
      oprot.writeI64(self.userId)
17345 
      oprot.writeFieldEnd()
17346 
    oprot.writeFieldStop()
17347 
    oprot.writeStructEnd()
17348 
 
17349 
  def validate(self):
17350 
    return
17351 
 
17352 
 
17353 
  def __repr__(self):
17354 
    L = ['%s=%r' % (key, value)
17355 
      for key, value in self.__dict__.iteritems()]
17356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17357 
 
17358 
  def __eq__(self, other):
17359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17360 
 
17361 
  def __ne__(self, other):
17362 
    return not (self == other)
17363 
 
17364 
class getBillingAddressForUser_result:
17365 
  """
17366 
  Attributes:
17367 
   - success
17368 
  """
17369 
 
17370 
  thrift_spec = (
17371 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17372 
  )
17373 
 
17374 
  def __init__(self, success=None,):
17375 
    self.success = success
17376 
 
17377 
  def read(self, iprot):
17378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17380 
      return
17381 
    iprot.readStructBegin()
17382 
    while True:
17383 
      (fname, ftype, fid) = iprot.readFieldBegin()
17384 
      if ftype == TType.STOP:
17385 
        break
17386 
      if fid == 0:
17387 
        if ftype == TType.STRUCT:
17388 
          self.success = Address()
17389 
          self.success.read(iprot)
17390 
        else:
17391 
          iprot.skip(ftype)
17392 
      else:
17393 
        iprot.skip(ftype)
17394 
      iprot.readFieldEnd()
17395 
    iprot.readStructEnd()
17396 
 
17397 
  def write(self, oprot):
17398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17400 
      return
17401 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17402 
    if self.success is not None:
17403 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17404 
      self.success.write(oprot)
17405 
      oprot.writeFieldEnd()
17406 
    oprot.writeFieldStop()
17407 
    oprot.writeStructEnd()
17408 
 
17409 
  def validate(self):
17410 
    return
17411 
 
17412 
 
17413 
  def __repr__(self):
17414 
    L = ['%s=%r' % (key, value)
17415 
      for key, value in self.__dict__.iteritems()]
17416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17417 
 
17418 
  def __eq__(self, other):
17419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17420 
 
17421 
  def __ne__(self, other):
17422 
    return not (self == other)
18590 manish.sha 17423 
 
17424 
class isCreditorAssigned_args:
17425 
  """
17426 
  Attributes:
17427 
   - userId
17428 
  """
17429 
 
17430 
  thrift_spec = (
17431 
    None, # 0
17432 
    (1, TType.I64, 'userId', None, None, ), # 1
17433 
  )
17434 
 
17435 
  def __init__(self, userId=None,):
17436 
    self.userId = userId
17437 
 
17438 
  def read(self, iprot):
17439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17441 
      return
17442 
    iprot.readStructBegin()
17443 
    while True:
17444 
      (fname, ftype, fid) = iprot.readFieldBegin()
17445 
      if ftype == TType.STOP:
17446 
        break
17447 
      if fid == 1:
17448 
        if ftype == TType.I64:
17449 
          self.userId = iprot.readI64();
17450 
        else:
17451 
          iprot.skip(ftype)
17452 
      else:
17453 
        iprot.skip(ftype)
17454 
      iprot.readFieldEnd()
17455 
    iprot.readStructEnd()
17456 
 
17457 
  def write(self, oprot):
17458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17460 
      return
17461 
    oprot.writeStructBegin('isCreditorAssigned_args')
17462 
    if self.userId is not None:
17463 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17464 
      oprot.writeI64(self.userId)
17465 
      oprot.writeFieldEnd()
17466 
    oprot.writeFieldStop()
17467 
    oprot.writeStructEnd()
17468 
 
17469 
  def validate(self):
17470 
    return
17471 
 
17472 
 
17473 
  def __repr__(self):
17474 
    L = ['%s=%r' % (key, value)
17475 
      for key, value in self.__dict__.iteritems()]
17476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17477 
 
17478 
  def __eq__(self, other):
17479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17480 
 
17481 
  def __ne__(self, other):
17482 
    return not (self == other)
17483 
 
17484 
class isCreditorAssigned_result:
17485 
  """
17486 
  Attributes:
17487 
   - success
17488 
  """
17489 
 
17490 
  thrift_spec = (
17491 
    (0, TType.BOOL, 'success', None, None, ), # 0
17492 
  )
17493 
 
17494 
  def __init__(self, success=None,):
17495 
    self.success = success
17496 
 
17497 
  def read(self, iprot):
17498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17500 
      return
17501 
    iprot.readStructBegin()
17502 
    while True:
17503 
      (fname, ftype, fid) = iprot.readFieldBegin()
17504 
      if ftype == TType.STOP:
17505 
        break
17506 
      if fid == 0:
17507 
        if ftype == TType.BOOL:
17508 
          self.success = iprot.readBool();
17509 
        else:
17510 
          iprot.skip(ftype)
17511 
      else:
17512 
        iprot.skip(ftype)
17513 
      iprot.readFieldEnd()
17514 
    iprot.readStructEnd()
17515 
 
17516 
  def write(self, oprot):
17517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17519 
      return
17520 
    oprot.writeStructBegin('isCreditorAssigned_result')
17521 
    if self.success is not None:
17522 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17523 
      oprot.writeBool(self.success)
17524 
      oprot.writeFieldEnd()
17525 
    oprot.writeFieldStop()
17526 
    oprot.writeStructEnd()
17527 
 
17528 
  def validate(self):
17529 
    return
17530 
 
17531 
 
17532 
  def __repr__(self):
17533 
    L = ['%s=%r' % (key, value)
17534 
      for key, value in self.__dict__.iteritems()]
17535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17536 
 
17537 
  def __eq__(self, other):
17538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17539 
 
17540 
  def __ne__(self, other):
17541 
    return not (self == other)
18735 manish.sha 17542 
 
17543 
class isTaxInvoiceEnabledUser_args:
17544 
  """
17545 
  Attributes:
17546 
   - userId
17547 
  """
17548 
 
17549 
  thrift_spec = (
17550 
    None, # 0
17551 
    (1, TType.I64, 'userId', None, None, ), # 1
17552 
  )
17553 
 
17554 
  def __init__(self, userId=None,):
17555 
    self.userId = userId
17556 
 
17557 
  def read(self, iprot):
17558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17560 
      return
17561 
    iprot.readStructBegin()
17562 
    while True:
17563 
      (fname, ftype, fid) = iprot.readFieldBegin()
17564 
      if ftype == TType.STOP:
17565 
        break
17566 
      if fid == 1:
17567 
        if ftype == TType.I64:
17568 
          self.userId = iprot.readI64();
17569 
        else:
17570 
          iprot.skip(ftype)
17571 
      else:
17572 
        iprot.skip(ftype)
17573 
      iprot.readFieldEnd()
17574 
    iprot.readStructEnd()
17575 
 
17576 
  def write(self, oprot):
17577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17579 
      return
17580 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17581 
    if self.userId is not None:
17582 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17583 
      oprot.writeI64(self.userId)
17584 
      oprot.writeFieldEnd()
17585 
    oprot.writeFieldStop()
17586 
    oprot.writeStructEnd()
17587 
 
17588 
  def validate(self):
17589 
    return
17590 
 
17591 
 
17592 
  def __repr__(self):
17593 
    L = ['%s=%r' % (key, value)
17594 
      for key, value in self.__dict__.iteritems()]
17595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17596 
 
17597 
  def __eq__(self, other):
17598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17599 
 
17600 
  def __ne__(self, other):
17601 
    return not (self == other)
17602 
 
17603 
class isTaxInvoiceEnabledUser_result:
17604 
  """
17605 
  Attributes:
17606 
   - success
17607 
  """
17608 
 
17609 
  thrift_spec = (
17610 
    (0, TType.BOOL, 'success', None, None, ), # 0
17611 
  )
17612 
 
17613 
  def __init__(self, success=None,):
17614 
    self.success = success
17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 0:
17626 
        if ftype == TType.BOOL:
17627 
          self.success = iprot.readBool();
17628 
        else:
17629 
          iprot.skip(ftype)
17630 
      else:
17631 
        iprot.skip(ftype)
17632 
      iprot.readFieldEnd()
17633 
    iprot.readStructEnd()
17634 
 
17635 
  def write(self, oprot):
17636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17638 
      return
17639 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17640 
    if self.success is not None:
17641 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17642 
      oprot.writeBool(self.success)
17643 
      oprot.writeFieldEnd()
17644 
    oprot.writeFieldStop()
17645 
    oprot.writeStructEnd()
17646 
 
17647 
  def validate(self):
17648 
    return
17649 
 
17650 
 
17651 
  def __repr__(self):
17652 
    L = ['%s=%r' % (key, value)
17653 
      for key, value in self.__dict__.iteritems()]
17654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17655 
 
17656 
  def __eq__(self, other):
17657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17658 
 
17659 
  def __ne__(self, other):
17660 
    return not (self == other)
18764 kshitij.so 17661 
 
19182 amit.gupta 17662 
class taxInvoiceAvailable_args:
17663 
  """
17664 
  Attributes:
17665 
   - addressId
17666 
  """
17667 
 
17668 
  thrift_spec = (
17669 
    None, # 0
17670 
    (1, TType.I64, 'addressId', None, None, ), # 1
17671 
  )
17672 
 
17673 
  def __init__(self, addressId=None,):
17674 
    self.addressId = addressId
17675 
 
17676 
  def read(self, iprot):
17677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17679 
      return
17680 
    iprot.readStructBegin()
17681 
    while True:
17682 
      (fname, ftype, fid) = iprot.readFieldBegin()
17683 
      if ftype == TType.STOP:
17684 
        break
17685 
      if fid == 1:
17686 
        if ftype == TType.I64:
17687 
          self.addressId = iprot.readI64();
17688 
        else:
17689 
          iprot.skip(ftype)
17690 
      else:
17691 
        iprot.skip(ftype)
17692 
      iprot.readFieldEnd()
17693 
    iprot.readStructEnd()
17694 
 
17695 
  def write(self, oprot):
17696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17698 
      return
17699 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
17700 
    if self.addressId is not None:
17701 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
17702 
      oprot.writeI64(self.addressId)
17703 
      oprot.writeFieldEnd()
17704 
    oprot.writeFieldStop()
17705 
    oprot.writeStructEnd()
17706 
 
17707 
  def validate(self):
17708 
    return
17709 
 
17710 
 
17711 
  def __repr__(self):
17712 
    L = ['%s=%r' % (key, value)
17713 
      for key, value in self.__dict__.iteritems()]
17714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17715 
 
17716 
  def __eq__(self, other):
17717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17718 
 
17719 
  def __ne__(self, other):
17720 
    return not (self == other)
17721 
 
17722 
class taxInvoiceAvailable_result:
17723 
  """
17724 
  Attributes:
17725 
   - success
17726 
  """
17727 
 
17728 
  thrift_spec = (
17729 
    (0, TType.BOOL, 'success', None, None, ), # 0
17730 
  )
17731 
 
17732 
  def __init__(self, success=None,):
17733 
    self.success = success
17734 
 
17735 
  def read(self, iprot):
17736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17738 
      return
17739 
    iprot.readStructBegin()
17740 
    while True:
17741 
      (fname, ftype, fid) = iprot.readFieldBegin()
17742 
      if ftype == TType.STOP:
17743 
        break
17744 
      if fid == 0:
17745 
        if ftype == TType.BOOL:
17746 
          self.success = iprot.readBool();
17747 
        else:
17748 
          iprot.skip(ftype)
17749 
      else:
17750 
        iprot.skip(ftype)
17751 
      iprot.readFieldEnd()
17752 
    iprot.readStructEnd()
17753 
 
17754 
  def write(self, oprot):
17755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17757 
      return
17758 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
17759 
    if self.success is not None:
17760 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17761 
      oprot.writeBool(self.success)
17762 
      oprot.writeFieldEnd()
17763 
    oprot.writeFieldStop()
17764 
    oprot.writeStructEnd()
17765 
 
17766 
  def validate(self):
17767 
    return
17768 
 
17769 
 
17770 
  def __repr__(self):
17771 
    L = ['%s=%r' % (key, value)
17772 
      for key, value in self.__dict__.iteritems()]
17773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17774 
 
17775 
  def __eq__(self, other):
17776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17777 
 
17778 
  def __ne__(self, other):
17779 
    return not (self == other)
17780 
 
18764 kshitij.so 17781 
class getCartByValue_args:
17782 
  """
17783 
  Attributes:
17784 
   - cartIds
17785 
  """
17786 
 
17787 
  thrift_spec = (
17788 
    None, # 0
17789 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17790 
  )
17791 
 
17792 
  def __init__(self, cartIds=None,):
17793 
    self.cartIds = cartIds
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      if fid == 1:
17805 
        if ftype == TType.LIST:
17806 
          self.cartIds = []
17807 
          (_etype258, _size255) = iprot.readListBegin()
17808 
          for _i259 in xrange(_size255):
17809 
            _elem260 = iprot.readI64();
17810 
            self.cartIds.append(_elem260)
17811 
          iprot.readListEnd()
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      else:
17815 
        iprot.skip(ftype)
17816 
      iprot.readFieldEnd()
17817 
    iprot.readStructEnd()
17818 
 
17819 
  def write(self, oprot):
17820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17822 
      return
17823 
    oprot.writeStructBegin('getCartByValue_args')
17824 
    if self.cartIds is not None:
17825 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17826 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17827 
      for iter261 in self.cartIds:
17828 
        oprot.writeI64(iter261)
17829 
      oprot.writeListEnd()
17830 
      oprot.writeFieldEnd()
17831 
    oprot.writeFieldStop()
17832 
    oprot.writeStructEnd()
17833 
 
17834 
  def validate(self):
17835 
    return
17836 
 
17837 
 
17838 
  def __repr__(self):
17839 
    L = ['%s=%r' % (key, value)
17840 
      for key, value in self.__dict__.iteritems()]
17841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17842 
 
17843 
  def __eq__(self, other):
17844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17845 
 
17846 
  def __ne__(self, other):
17847 
    return not (self == other)
17848 
 
17849 
class getCartByValue_result:
17850 
  """
17851 
  Attributes:
17852 
   - success
17853 
  """
17854 
 
17855 
  thrift_spec = (
17856 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17857 
  )
17858 
 
17859 
  def __init__(self, success=None,):
17860 
    self.success = success
17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      if fid == 0:
17872 
        if ftype == TType.MAP:
17873 
          self.success = {}
17874 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17875 
          for _i266 in xrange(_size262):
17876 
            _key267 = iprot.readI64();
17877 
            _val268 = []
17878 
            (_etype272, _size269) = iprot.readListBegin()
17879 
            for _i273 in xrange(_size269):
17880 
              _elem274 = Line()
17881 
              _elem274.read(iprot)
17882 
              _val268.append(_elem274)
17883 
            iprot.readListEnd()
17884 
            self.success[_key267] = _val268
17885 
          iprot.readMapEnd()
17886 
        else:
17887 
          iprot.skip(ftype)
17888 
      else:
17889 
        iprot.skip(ftype)
17890 
      iprot.readFieldEnd()
17891 
    iprot.readStructEnd()
17892 
 
17893 
  def write(self, oprot):
17894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17896 
      return
17897 
    oprot.writeStructBegin('getCartByValue_result')
17898 
    if self.success is not None:
17899 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17900 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17901 
      for kiter275,viter276 in self.success.items():
17902 
        oprot.writeI64(kiter275)
17903 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17904 
        for iter277 in viter276:
17905 
          iter277.write(oprot)
17906 
        oprot.writeListEnd()
17907 
      oprot.writeMapEnd()
17908 
      oprot.writeFieldEnd()
17909 
    oprot.writeFieldStop()
17910 
    oprot.writeStructEnd()
17911 
 
17912 
  def validate(self):
17913 
    return
17914 
 
17915 
 
17916 
  def __repr__(self):
17917 
    L = ['%s=%r' % (key, value)
17918 
      for key, value in self.__dict__.iteritems()]
17919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17920 
 
17921 
  def __eq__(self, other):
17922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17923 
 
17924 
  def __ne__(self, other):
17925 
    return not (self == other)
19889 manas 17926 
 
17927 
class getCounterName_args:
17928 
  """
17929 
  Attributes:
17930 
   - userIds
17931 
  """
17932 
 
17933 
  thrift_spec = (
17934 
    None, # 0
17935 
    (1, TType.LIST, 'userIds', (TType.I64,None), None, ), # 1
17936 
  )
17937 
 
17938 
  def __init__(self, userIds=None,):
17939 
    self.userIds = userIds
17940 
 
17941 
  def read(self, iprot):
17942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17944 
      return
17945 
    iprot.readStructBegin()
17946 
    while True:
17947 
      (fname, ftype, fid) = iprot.readFieldBegin()
17948 
      if ftype == TType.STOP:
17949 
        break
17950 
      if fid == 1:
17951 
        if ftype == TType.LIST:
17952 
          self.userIds = []
17953 
          (_etype281, _size278) = iprot.readListBegin()
17954 
          for _i282 in xrange(_size278):
17955 
            _elem283 = iprot.readI64();
17956 
            self.userIds.append(_elem283)
17957 
          iprot.readListEnd()
17958 
        else:
17959 
          iprot.skip(ftype)
17960 
      else:
17961 
        iprot.skip(ftype)
17962 
      iprot.readFieldEnd()
17963 
    iprot.readStructEnd()
17964 
 
17965 
  def write(self, oprot):
17966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17968 
      return
17969 
    oprot.writeStructBegin('getCounterName_args')
17970 
    if self.userIds is not None:
17971 
      oprot.writeFieldBegin('userIds', TType.LIST, 1)
17972 
      oprot.writeListBegin(TType.I64, len(self.userIds))
17973 
      for iter284 in self.userIds:
17974 
        oprot.writeI64(iter284)
17975 
      oprot.writeListEnd()
17976 
      oprot.writeFieldEnd()
17977 
    oprot.writeFieldStop()
17978 
    oprot.writeStructEnd()
17979 
 
17980 
  def validate(self):
17981 
    return
17982 
 
17983 
 
17984 
  def __repr__(self):
17985 
    L = ['%s=%r' % (key, value)
17986 
      for key, value in self.__dict__.iteritems()]
17987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17988 
 
17989 
  def __eq__(self, other):
17990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17991 
 
17992 
  def __ne__(self, other):
17993 
    return not (self == other)
17994 
 
17995 
class getCounterName_result:
17996 
  """
17997 
  Attributes:
17998 
   - success
17999 
  """
18000 
 
18001 
  thrift_spec = (
18002 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
18003 
  )
18004 
 
18005 
  def __init__(self, success=None,):
18006 
    self.success = success
18007 
 
18008 
  def read(self, iprot):
18009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18011 
      return
18012 
    iprot.readStructBegin()
18013 
    while True:
18014 
      (fname, ftype, fid) = iprot.readFieldBegin()
18015 
      if ftype == TType.STOP:
18016 
        break
18017 
      if fid == 0:
18018 
        if ftype == TType.MAP:
18019 
          self.success = {}
18020 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
18021 
          for _i289 in xrange(_size285):
18022 
            _key290 = iprot.readI64();
18023 
            _val291 = iprot.readString();
18024 
            self.success[_key290] = _val291
18025 
          iprot.readMapEnd()
18026 
        else:
18027 
          iprot.skip(ftype)
18028 
      else:
18029 
        iprot.skip(ftype)
18030 
      iprot.readFieldEnd()
18031 
    iprot.readStructEnd()
18032 
 
18033 
  def write(self, oprot):
18034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18036 
      return
18037 
    oprot.writeStructBegin('getCounterName_result')
18038 
    if self.success is not None:
18039 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18040 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
18041 
      for kiter292,viter293 in self.success.items():
18042 
        oprot.writeI64(kiter292)
18043 
        oprot.writeString(viter293)
18044 
      oprot.writeMapEnd()
18045 
      oprot.writeFieldEnd()
18046 
    oprot.writeFieldStop()
18047 
    oprot.writeStructEnd()
18048 
 
18049 
  def validate(self):
18050 
    return
18051 
 
18052 
 
18053 
  def __repr__(self):
18054 
    L = ['%s=%r' % (key, value)
18055 
      for key, value in self.__dict__.iteritems()]
18056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18057 
 
18058 
  def __eq__(self, other):
18059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18060 
 
18061 
  def __ne__(self, other):
18062 
    return not (self == other)
20873 kshitij.so 18063 
 
18064 
class setWalletAmountInCart_args:
18065 
  """
18066 
  Attributes:
18067 
   - cartId
18068 
   - wallet_amount
18069 
  """
18070 
 
18071 
  thrift_spec = (
18072 
    None, # 0
18073 
    (1, TType.I64, 'cartId', None, None, ), # 1
18074 
    (2, TType.DOUBLE, 'wallet_amount', None, None, ), # 2
18075 
  )
18076 
 
18077 
  def __init__(self, cartId=None, wallet_amount=None,):
18078 
    self.cartId = cartId
18079 
    self.wallet_amount = wallet_amount
18080 
 
18081 
  def read(self, iprot):
18082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18084 
      return
18085 
    iprot.readStructBegin()
18086 
    while True:
18087 
      (fname, ftype, fid) = iprot.readFieldBegin()
18088 
      if ftype == TType.STOP:
18089 
        break
18090 
      if fid == 1:
18091 
        if ftype == TType.I64:
18092 
          self.cartId = iprot.readI64();
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      elif fid == 2:
18096 
        if ftype == TType.DOUBLE:
18097 
          self.wallet_amount = iprot.readDouble();
18098 
        else:
18099 
          iprot.skip(ftype)
18100 
      else:
18101 
        iprot.skip(ftype)
18102 
      iprot.readFieldEnd()
18103 
    iprot.readStructEnd()
18104 
 
18105 
  def write(self, oprot):
18106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18108 
      return
18109 
    oprot.writeStructBegin('setWalletAmountInCart_args')
18110 
    if self.cartId is not None:
18111 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
18112 
      oprot.writeI64(self.cartId)
18113 
      oprot.writeFieldEnd()
18114 
    if self.wallet_amount is not None:
18115 
      oprot.writeFieldBegin('wallet_amount', TType.DOUBLE, 2)
18116 
      oprot.writeDouble(self.wallet_amount)
18117 
      oprot.writeFieldEnd()
18118 
    oprot.writeFieldStop()
18119 
    oprot.writeStructEnd()
18120 
 
18121 
  def validate(self):
18122 
    return
18123 
 
18124 
 
18125 
  def __repr__(self):
18126 
    L = ['%s=%r' % (key, value)
18127 
      for key, value in self.__dict__.iteritems()]
18128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18129 
 
18130 
  def __eq__(self, other):
18131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18132 
 
18133 
  def __ne__(self, other):
18134 
    return not (self == other)
18135 
 
18136 
class setWalletAmountInCart_result:
18137 
  """
18138 
  Attributes:
18139 
   - success
18140 
  """
18141 
 
18142 
  thrift_spec = (
18143 
    (0, TType.BOOL, 'success', None, None, ), # 0
18144 
  )
18145 
 
18146 
  def __init__(self, success=None,):
18147 
    self.success = success
18148 
 
18149 
  def read(self, iprot):
18150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18152 
      return
18153 
    iprot.readStructBegin()
18154 
    while True:
18155 
      (fname, ftype, fid) = iprot.readFieldBegin()
18156 
      if ftype == TType.STOP:
18157 
        break
18158 
      if fid == 0:
18159 
        if ftype == TType.BOOL:
18160 
          self.success = iprot.readBool();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      else:
18164 
        iprot.skip(ftype)
18165 
      iprot.readFieldEnd()
18166 
    iprot.readStructEnd()
18167 
 
18168 
  def write(self, oprot):
18169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18171 
      return
18172 
    oprot.writeStructBegin('setWalletAmountInCart_result')
18173 
    if self.success is not None:
18174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18175 
      oprot.writeBool(self.success)
18176 
      oprot.writeFieldEnd()
18177 
    oprot.writeFieldStop()
18178 
    oprot.writeStructEnd()
18179 
 
18180 
  def validate(self):
18181 
    return
18182 
 
18183 
 
18184 
  def __repr__(self):
18185 
    L = ['%s=%r' % (key, value)
18186 
      for key, value in self.__dict__.iteritems()]
18187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18188 
 
18189 
  def __eq__(self, other):
18190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18191 
 
18192 
  def __ne__(self, other):
18193 
    return not (self == other)