Subversion Repositories SmartDukaan

Rev

Rev 18977 | Rev 19889 | 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 
 
18764 kshitij.so 802 
 
3376 rajveer 803 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 804 
  """
805 
  service
806 
  """
807 
  def __init__(self, iprot, oprot=None):
3376 rajveer 808 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 809 
 
559 chandransh 810 
  def createAnonymousUser(self, jsessionId):
94 ashish 811 
    """
812 
    Parameters:
559 chandransh 813 
     - jsessionId
94 ashish 814 
    """
559 chandransh 815 
    self.send_createAnonymousUser(jsessionId)
816 
    return self.recv_createAnonymousUser()
94 ashish 817 
 
559 chandransh 818 
  def send_createAnonymousUser(self, jsessionId):
819 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
820 
    args = createAnonymousUser_args()
821 
    args.jsessionId = jsessionId
94 ashish 822 
    args.write(self._oprot)
823 
    self._oprot.writeMessageEnd()
824 
    self._oprot.trans.flush()
825 
 
559 chandransh 826 
  def recv_createAnonymousUser(self, ):
94 ashish 827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
828 
    if mtype == TMessageType.EXCEPTION:
829 
      x = TApplicationException()
830 
      x.read(self._iprot)
831 
      self._iprot.readMessageEnd()
832 
      raise x
559 chandransh 833 
    result = createAnonymousUser_result()
94 ashish 834 
    result.read(self._iprot)
835 
    self._iprot.readMessageEnd()
3431 rajveer 836 
    if result.success is not None:
94 ashish 837 
      return result.success
3431 rajveer 838 
    if result.ucex is not None:
559 chandransh 839 
      raise result.ucex
840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 841 
 
559 chandransh 842 
  def getUserById(self, userId):
94 ashish 843 
    """
844 
    Parameters:
845 
     - userId
846 
    """
559 chandransh 847 
    self.send_getUserById(userId)
848 
    return self.recv_getUserById()
94 ashish 849 
 
559 chandransh 850 
  def send_getUserById(self, userId):
851 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
852 
    args = getUserById_args()
94 ashish 853 
    args.userId = userId
854 
    args.write(self._oprot)
855 
    self._oprot.writeMessageEnd()
856 
    self._oprot.trans.flush()
857 
 
559 chandransh 858 
  def recv_getUserById(self, ):
94 ashish 859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
860 
    if mtype == TMessageType.EXCEPTION:
861 
      x = TApplicationException()
862 
      x.read(self._iprot)
863 
      self._iprot.readMessageEnd()
864 
      raise x
559 chandransh 865 
    result = getUserById_result()
94 ashish 866 
    result.read(self._iprot)
867 
    self._iprot.readMessageEnd()
3431 rajveer 868 
    if result.success is not None:
94 ashish 869 
      return result.success
3431 rajveer 870 
    if result.ucex is not None:
559 chandransh 871 
      raise result.ucex
872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 873 
 
5326 rajveer 874 
  def getUserByCartId(self, cartId):
875 
    """
876 
    Parameters:
877 
     - cartId
878 
    """
879 
    self.send_getUserByCartId(cartId)
880 
    return self.recv_getUserByCartId()
881 
 
882 
  def send_getUserByCartId(self, cartId):
883 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
884 
    args = getUserByCartId_args()
885 
    args.cartId = cartId
886 
    args.write(self._oprot)
887 
    self._oprot.writeMessageEnd()
888 
    self._oprot.trans.flush()
889 
 
890 
  def recv_getUserByCartId(self, ):
891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
892 
    if mtype == TMessageType.EXCEPTION:
893 
      x = TApplicationException()
894 
      x.read(self._iprot)
895 
      self._iprot.readMessageEnd()
896 
      raise x
897 
    result = getUserByCartId_result()
898 
    result.read(self._iprot)
899 
    self._iprot.readMessageEnd()
900 
    if result.success is not None:
901 
      return result.success
902 
    if result.ucex is not None:
903 
      raise result.ucex
904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
905 
 
1491 vikas 906 
  def getUserByEmail(self, email):
907 
    """
908 
    Parameters:
909 
     - email
910 
    """
911 
    self.send_getUserByEmail(email)
912 
    return self.recv_getUserByEmail()
913 
 
914 
  def send_getUserByEmail(self, email):
915 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
916 
    args = getUserByEmail_args()
917 
    args.email = email
918 
    args.write(self._oprot)
919 
    self._oprot.writeMessageEnd()
920 
    self._oprot.trans.flush()
921 
 
922 
  def recv_getUserByEmail(self, ):
923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
924 
    if mtype == TMessageType.EXCEPTION:
925 
      x = TApplicationException()
926 
      x.read(self._iprot)
927 
      self._iprot.readMessageEnd()
928 
      raise x
929 
    result = getUserByEmail_result()
930 
    result.read(self._iprot)
931 
    self._iprot.readMessageEnd()
3431 rajveer 932 
    if result.success is not None:
1491 vikas 933 
      return result.success
3431 rajveer 934 
    if result.ucex is not None:
1491 vikas 935 
      raise result.ucex
936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
937 
 
3032 mandeep.dh 938 
  def getUserByMobileNumber(self, mobileNumber):
939 
    """
940 
    Parameters:
941 
     - mobileNumber
942 
    """
943 
    self.send_getUserByMobileNumber(mobileNumber)
944 
    return self.recv_getUserByMobileNumber()
945 
 
946 
  def send_getUserByMobileNumber(self, mobileNumber):
947 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
948 
    args = getUserByMobileNumber_args()
949 
    args.mobileNumber = mobileNumber
950 
    args.write(self._oprot)
951 
    self._oprot.writeMessageEnd()
952 
    self._oprot.trans.flush()
953 
 
954 
  def recv_getUserByMobileNumber(self, ):
955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
956 
    if mtype == TMessageType.EXCEPTION:
957 
      x = TApplicationException()
958 
      x.read(self._iprot)
959 
      self._iprot.readMessageEnd()
960 
      raise x
961 
    result = getUserByMobileNumber_result()
962 
    result.read(self._iprot)
963 
    self._iprot.readMessageEnd()
3431 rajveer 964 
    if result.success is not None:
3032 mandeep.dh 965 
      return result.success
3431 rajveer 966 
    if result.ucex is not None:
3032 mandeep.dh 967 
      raise result.ucex
968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
969 
 
559 chandransh 970 
  def createUser(self, user):
94 ashish 971 
    """
972 
    Parameters:
559 chandransh 973 
     - user
94 ashish 974 
    """
559 chandransh 975 
    self.send_createUser(user)
976 
    return self.recv_createUser()
94 ashish 977 
 
559 chandransh 978 
  def send_createUser(self, user):
979 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
980 
    args = createUser_args()
981 
    args.user = user
94 ashish 982 
    args.write(self._oprot)
983 
    self._oprot.writeMessageEnd()
984 
    self._oprot.trans.flush()
985 
 
559 chandransh 986 
  def recv_createUser(self, ):
94 ashish 987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
988 
    if mtype == TMessageType.EXCEPTION:
989 
      x = TApplicationException()
990 
      x.read(self._iprot)
991 
      self._iprot.readMessageEnd()
992 
      raise x
559 chandransh 993 
    result = createUser_result()
94 ashish 994 
    result.read(self._iprot)
995 
    self._iprot.readMessageEnd()
3431 rajveer 996 
    if result.success is not None:
94 ashish 997 
      return result.success
3431 rajveer 998 
    if result.ucex is not None:
559 chandransh 999 
      raise result.ucex
1000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 1001 
 
559 chandransh 1002 
  def updateUser(self, user):
94 ashish 1003 
    """
1004 
    Parameters:
559 chandransh 1005 
     - user
94 ashish 1006 
    """
559 chandransh 1007 
    self.send_updateUser(user)
1008 
    return self.recv_updateUser()
94 ashish 1009 
 
559 chandransh 1010 
  def send_updateUser(self, user):
1011 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1012 
    args = updateUser_args()
1013 
    args.user = user
94 ashish 1014 
    args.write(self._oprot)
1015 
    self._oprot.writeMessageEnd()
1016 
    self._oprot.trans.flush()
1017 
 
559 chandransh 1018 
  def recv_updateUser(self, ):
94 ashish 1019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1020 
    if mtype == TMessageType.EXCEPTION:
1021 
      x = TApplicationException()
1022 
      x.read(self._iprot)
1023 
      self._iprot.readMessageEnd()
1024 
      raise x
559 chandransh 1025 
    result = updateUser_result()
94 ashish 1026 
    result.read(self._iprot)
1027 
    self._iprot.readMessageEnd()
3431 rajveer 1028 
    if result.success is not None:
94 ashish 1029 
      return result.success
3431 rajveer 1030 
    if result.ucex is not None:
559 chandransh 1031 
      raise result.ucex
1032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1033 
 
559 chandransh 1034 
  def authenticateUser(self, email, password):
94 ashish 1035 
    """
1036 
    Parameters:
1037 
     - email
1038 
     - password
1039 
    """
559 chandransh 1040 
    self.send_authenticateUser(email, password)
122 ashish 1041 
    return self.recv_authenticateUser()
1042 
 
559 chandransh 1043 
  def send_authenticateUser(self, email, password):
122 ashish 1044 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1045 
    args = authenticateUser_args()
559 chandransh 1046 
    args.email = email
122 ashish 1047 
    args.password = password
1048 
    args.write(self._oprot)
1049 
    self._oprot.writeMessageEnd()
1050 
    self._oprot.trans.flush()
1051 
 
1052 
  def recv_authenticateUser(self, ):
1053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1054 
    if mtype == TMessageType.EXCEPTION:
1055 
      x = TApplicationException()
1056 
      x.read(self._iprot)
1057 
      self._iprot.readMessageEnd()
1058 
      raise x
1059 
    result = authenticateUser_result()
1060 
    result.read(self._iprot)
1061 
    self._iprot.readMessageEnd()
3431 rajveer 1062 
    if result.success is not None:
122 ashish 1063 
      return result.success
3431 rajveer 1064 
    if result.auex is not None:
559 chandransh 1065 
      raise result.auex
122 ashish 1066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1067 
 
94 ashish 1068 
  def userExists(self, email):
1069 
    """
1070 
    Parameters:
1071 
     - email
1072 
    """
1073 
    self.send_userExists(email)
1074 
    return self.recv_userExists()
1075 
 
1076 
  def send_userExists(self, email):
1077 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1078 
    args = userExists_args()
1079 
    args.email = email
1080 
    args.write(self._oprot)
1081 
    self._oprot.writeMessageEnd()
1082 
    self._oprot.trans.flush()
1083 
 
1084 
  def recv_userExists(self, ):
1085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1086 
    if mtype == TMessageType.EXCEPTION:
1087 
      x = TApplicationException()
1088 
      x.read(self._iprot)
1089 
      self._iprot.readMessageEnd()
1090 
      raise x
1091 
    result = userExists_result()
1092 
    result.read(self._iprot)
1093 
    self._iprot.readMessageEnd()
3431 rajveer 1094 
    if result.success is not None:
94 ashish 1095 
      return result.success
3431 rajveer 1096 
    if result.ucx is not None:
94 ashish 1097 
      raise result.ucx
1098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1099 
 
567 rajveer 1100 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1101 
    """
1102 
    Parameters:
1103 
     - userId
1104 
     - address
513 rajveer 1105 
     - setDefault
94 ashish 1106 
    """
567 rajveer 1107 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1108 
    return self.recv_addAddressForUser()
1109 
 
567 rajveer 1110 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1111 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1112 
    args = addAddressForUser_args()
559 chandransh 1113 
    args.userId = userId
94 ashish 1114 
    args.address = address
513 rajveer 1115 
    args.setDefault = setDefault
94 ashish 1116 
    args.write(self._oprot)
1117 
    self._oprot.writeMessageEnd()
1118 
    self._oprot.trans.flush()
1119 
 
1120 
  def recv_addAddressForUser(self, ):
1121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1122 
    if mtype == TMessageType.EXCEPTION:
1123 
      x = TApplicationException()
1124 
      x.read(self._iprot)
1125 
      self._iprot.readMessageEnd()
1126 
      raise x
1127 
    result = addAddressForUser_result()
1128 
    result.read(self._iprot)
1129 
    self._iprot.readMessageEnd()
3431 rajveer 1130 
    if result.success is not None:
94 ashish 1131 
      return result.success
3431 rajveer 1132 
    if result.ucx is not None:
94 ashish 1133 
      raise result.ucx
1134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1135 
 
1136 
  def removeAddressForUser(self, userid, addressId):
1137 
    """
1138 
    Parameters:
1139 
     - userid
1140 
     - addressId
1141 
    """
1142 
    self.send_removeAddressForUser(userid, addressId)
1143 
    return self.recv_removeAddressForUser()
1144 
 
1145 
  def send_removeAddressForUser(self, userid, addressId):
1146 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1147 
    args = removeAddressForUser_args()
1148 
    args.userid = userid
1149 
    args.addressId = addressId
1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_removeAddressForUser(self, ):
1155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1156 
    if mtype == TMessageType.EXCEPTION:
1157 
      x = TApplicationException()
1158 
      x.read(self._iprot)
1159 
      self._iprot.readMessageEnd()
1160 
      raise x
1161 
    result = removeAddressForUser_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
3431 rajveer 1164 
    if result.success is not None:
94 ashish 1165 
      return result.success
3431 rajveer 1166 
    if result.ucx is not None:
94 ashish 1167 
      raise result.ucx
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1169 
 
1170 
  def setUserAsLoggedIn(self, userId, timestamp):
1171 
    """
1172 
    Parameters:
1173 
     - userId
1174 
     - timestamp
1175 
    """
1176 
    self.send_setUserAsLoggedIn(userId, timestamp)
1177 
    return self.recv_setUserAsLoggedIn()
1178 
 
1179 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1180 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1181 
    args = setUserAsLoggedIn_args()
1182 
    args.userId = userId
1183 
    args.timestamp = timestamp
1184 
    args.write(self._oprot)
1185 
    self._oprot.writeMessageEnd()
1186 
    self._oprot.trans.flush()
1187 
 
1188 
  def recv_setUserAsLoggedIn(self, ):
1189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1190 
    if mtype == TMessageType.EXCEPTION:
1191 
      x = TApplicationException()
1192 
      x.read(self._iprot)
1193 
      self._iprot.readMessageEnd()
1194 
      raise x
1195 
    result = setUserAsLoggedIn_result()
1196 
    result.read(self._iprot)
1197 
    self._iprot.readMessageEnd()
3431 rajveer 1198 
    if result.success is not None:
94 ashish 1199 
      return result.success
3431 rajveer 1200 
    if result.ucx is not None:
94 ashish 1201 
      raise result.ucx
1202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1203 
 
1204 
  def setUserAsLoggedOut(self, userid, timestamp):
1205 
    """
1206 
    Parameters:
1207 
     - userid
1208 
     - timestamp
1209 
    """
1210 
    self.send_setUserAsLoggedOut(userid, timestamp)
1211 
    return self.recv_setUserAsLoggedOut()
1212 
 
1213 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1214 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1215 
    args = setUserAsLoggedOut_args()
1216 
    args.userid = userid
1217 
    args.timestamp = timestamp
1218 
    args.write(self._oprot)
1219 
    self._oprot.writeMessageEnd()
1220 
    self._oprot.trans.flush()
1221 
 
1222 
  def recv_setUserAsLoggedOut(self, ):
1223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1224 
    if mtype == TMessageType.EXCEPTION:
1225 
      x = TApplicationException()
1226 
      x.read(self._iprot)
1227 
      self._iprot.readMessageEnd()
1228 
      raise x
1229 
    result = setUserAsLoggedOut_result()
1230 
    result.read(self._iprot)
1231 
    self._iprot.readMessageEnd()
3431 rajveer 1232 
    if result.success is not None:
94 ashish 1233 
      return result.success
3431 rajveer 1234 
    if result.ucx is not None:
94 ashish 1235 
      raise result.ucx
1236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1237 
 
504 rajveer 1238 
  def setDefaultAddress(self, userid, addressId):
1239 
    """
1240 
    Parameters:
1241 
     - userid
1242 
     - addressId
1243 
    """
1244 
    self.send_setDefaultAddress(userid, addressId)
1245 
    return self.recv_setDefaultAddress()
1246 
 
1247 
  def send_setDefaultAddress(self, userid, addressId):
1248 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1249 
    args = setDefaultAddress_args()
1250 
    args.userid = userid
1251 
    args.addressId = addressId
1252 
    args.write(self._oprot)
1253 
    self._oprot.writeMessageEnd()
1254 
    self._oprot.trans.flush()
1255 
 
1256 
  def recv_setDefaultAddress(self, ):
1257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1258 
    if mtype == TMessageType.EXCEPTION:
1259 
      x = TApplicationException()
1260 
      x.read(self._iprot)
1261 
      self._iprot.readMessageEnd()
1262 
      raise x
1263 
    result = setDefaultAddress_result()
1264 
    result.read(self._iprot)
1265 
    self._iprot.readMessageEnd()
3431 rajveer 1266 
    if result.success is not None:
504 rajveer 1267 
      return result.success
3431 rajveer 1268 
    if result.ucx is not None:
504 rajveer 1269 
      raise result.ucx
1270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1271 
 
594 rajveer 1272 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1273 
    """
1274 
    Parameters:
1275 
     - userid
594 rajveer 1276 
     - oldPassword
1277 
     - newPassword
94 ashish 1278 
    """
594 rajveer 1279 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1280 
    return self.recv_updatePassword()
1281 
 
594 rajveer 1282 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1283 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1284 
    args = updatePassword_args()
1285 
    args.userid = userid
594 rajveer 1286 
    args.oldPassword = oldPassword
1287 
    args.newPassword = newPassword
94 ashish 1288 
    args.write(self._oprot)
1289 
    self._oprot.writeMessageEnd()
1290 
    self._oprot.trans.flush()
1291 
 
1292 
  def recv_updatePassword(self, ):
1293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1294 
    if mtype == TMessageType.EXCEPTION:
1295 
      x = TApplicationException()
1296 
      x.read(self._iprot)
1297 
      self._iprot.readMessageEnd()
1298 
      raise x
1299 
    result = updatePassword_result()
1300 
    result.read(self._iprot)
1301 
    self._iprot.readMessageEnd()
3431 rajveer 1302 
    if result.success is not None:
94 ashish 1303 
      return result.success
3431 rajveer 1304 
    if result.ucx is not None:
94 ashish 1305 
      raise result.ucx
1306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1307 
 
884 rajveer 1308 
  def forgotPassword(self, email, newPassword):
581 rajveer 1309 
    """
1310 
    Parameters:
1311 
     - email
884 rajveer 1312 
     - newPassword
581 rajveer 1313 
    """
884 rajveer 1314 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1315 
    return self.recv_forgotPassword()
1316 
 
884 rajveer 1317 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1318 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1319 
    args = forgotPassword_args()
1320 
    args.email = email
884 rajveer 1321 
    args.newPassword = newPassword
581 rajveer 1322 
    args.write(self._oprot)
1323 
    self._oprot.writeMessageEnd()
1324 
    self._oprot.trans.flush()
1325 
 
1326 
  def recv_forgotPassword(self, ):
1327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1328 
    if mtype == TMessageType.EXCEPTION:
1329 
      x = TApplicationException()
1330 
      x.read(self._iprot)
1331 
      self._iprot.readMessageEnd()
1332 
      raise x
1333 
    result = forgotPassword_result()
1334 
    result.read(self._iprot)
1335 
    self._iprot.readMessageEnd()
3431 rajveer 1336 
    if result.success is not None:
581 rajveer 1337 
      return result.success
3431 rajveer 1338 
    if result.ucx is not None:
581 rajveer 1339 
      raise result.ucx
1340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1341 
 
594 rajveer 1342 
  def getAllAddressesForUser(self, userId):
1343 
    """
1344 
    Parameters:
1345 
     - userId
1346 
    """
1347 
    self.send_getAllAddressesForUser(userId)
1348 
    return self.recv_getAllAddressesForUser()
1349 
 
1350 
  def send_getAllAddressesForUser(self, userId):
1351 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1352 
    args = getAllAddressesForUser_args()
1353 
    args.userId = userId
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1358 
  def recv_getAllAddressesForUser(self, ):
1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1365 
    result = getAllAddressesForUser_result()
1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
3431 rajveer 1368 
    if result.success is not None:
594 rajveer 1369 
      return result.success
3431 rajveer 1370 
    if result.ucx is not None:
594 rajveer 1371 
      raise result.ucx
1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1373 
 
1894 vikas 1374 
  def getAddressById(self, addressId):
1375 
    """
1376 
    Parameters:
1377 
     - addressId
1378 
    """
1379 
    self.send_getAddressById(addressId)
1380 
    return self.recv_getAddressById()
1381 
 
1382 
  def send_getAddressById(self, addressId):
1383 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1384 
    args = getAddressById_args()
1385 
    args.addressId = addressId
1386 
    args.write(self._oprot)
1387 
    self._oprot.writeMessageEnd()
1388 
    self._oprot.trans.flush()
1389 
 
1390 
  def recv_getAddressById(self, ):
1391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1392 
    if mtype == TMessageType.EXCEPTION:
1393 
      x = TApplicationException()
1394 
      x.read(self._iprot)
1395 
      self._iprot.readMessageEnd()
1396 
      raise x
1397 
    result = getAddressById_result()
1398 
    result.read(self._iprot)
1399 
    self._iprot.readMessageEnd()
3431 rajveer 1400 
    if result.success is not None:
1894 vikas 1401 
      return result.success
3431 rajveer 1402 
    if result.ucx is not None:
1894 vikas 1403 
      raise result.ucx
1404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1405 
 
594 rajveer 1406 
  def getDefaultAddressId(self, userId):
1407 
    """
1408 
    Parameters:
1409 
     - userId
1410 
    """
1411 
    self.send_getDefaultAddressId(userId)
1412 
    return self.recv_getDefaultAddressId()
1413 
 
1414 
  def send_getDefaultAddressId(self, userId):
1415 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1416 
    args = getDefaultAddressId_args()
1417 
    args.userId = userId
1418 
    args.write(self._oprot)
1419 
    self._oprot.writeMessageEnd()
1420 
    self._oprot.trans.flush()
1421 
 
1422 
  def recv_getDefaultAddressId(self, ):
1423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1424 
    if mtype == TMessageType.EXCEPTION:
1425 
      x = TApplicationException()
1426 
      x.read(self._iprot)
1427 
      self._iprot.readMessageEnd()
1428 
      raise x
1429 
    result = getDefaultAddressId_result()
1430 
    result.read(self._iprot)
1431 
    self._iprot.readMessageEnd()
3431 rajveer 1432 
    if result.success is not None:
594 rajveer 1433 
      return result.success
3431 rajveer 1434 
    if result.ucx is not None:
594 rajveer 1435 
      raise result.ucx
1436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1437 
 
785 rajveer 1438 
  def getDefaultPincode(self, userId):
1439 
    """
1440 
    Parameters:
1441 
     - userId
1442 
    """
1443 
    self.send_getDefaultPincode(userId)
1444 
    return self.recv_getDefaultPincode()
1445 
 
1446 
  def send_getDefaultPincode(self, userId):
1447 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1448 
    args = getDefaultPincode_args()
1449 
    args.userId = userId
1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getDefaultPincode(self, ):
1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
1461 
    result = getDefaultPincode_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
3431 rajveer 1464 
    if result.success is not None:
785 rajveer 1465 
      return result.success
3431 rajveer 1466 
    if result.ucx is not None:
785 rajveer 1467 
      raise result.ucx
1468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1469 
 
1274 varun.gupt 1470 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1471 
    """
1472 
    Parameters:
1473 
     - userId
1474 
     - replyTo
1475 
     - communicationType
1476 
     - orderId
1477 
     - airwaybillNo
1478 
     - productName
1479 
     - subject
1480 
     - message
1481 
    """
1482 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1483 
    return self.recv_saveUserCommunication()
1484 
 
1485 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1486 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1487 
    args = saveUserCommunication_args()
1488 
    args.userId = userId
1489 
    args.replyTo = replyTo
1490 
    args.communicationType = communicationType
1491 
    args.orderId = orderId
1492 
    args.airwaybillNo = airwaybillNo
1493 
    args.productName = productName
1494 
    args.subject = subject
1495 
    args.message = message
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_saveUserCommunication(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = saveUserCommunication_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
3431 rajveer 1510 
    if result.success is not None:
1274 varun.gupt 1511 
      return result.success
3431 rajveer 1512 
    if result.ucx is not None:
1274 varun.gupt 1513 
      raise result.ucx
1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1515 
 
1590 varun.gupt 1516 
  def getUserCommunicationById(self, id):
1517 
    """
1518 
    Parameters:
1519 
     - id
1520 
    """
1521 
    self.send_getUserCommunicationById(id)
1522 
    return self.recv_getUserCommunicationById()
1523 
 
1524 
  def send_getUserCommunicationById(self, id):
1525 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1526 
    args = getUserCommunicationById_args()
1527 
    args.id = id
1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
1532 
  def recv_getUserCommunicationById(self, ):
1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
1539 
    result = getUserCommunicationById_result()
1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
3431 rajveer 1542 
    if result.success is not None:
1590 varun.gupt 1543 
      return result.success
3431 rajveer 1544 
    if result.ucx is not None:
1590 varun.gupt 1545 
      raise result.ucx
1546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1547 
 
1548 
  def getUserCommunicationByUser(self, userId):
1549 
    """
1550 
    Parameters:
1551 
     - userId
1552 
    """
1553 
    self.send_getUserCommunicationByUser(userId)
1554 
    return self.recv_getUserCommunicationByUser()
1555 
 
1556 
  def send_getUserCommunicationByUser(self, userId):
1557 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1558 
    args = getUserCommunicationByUser_args()
1559 
    args.userId = userId
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_getUserCommunicationByUser(self, ):
1565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1566 
    if mtype == TMessageType.EXCEPTION:
1567 
      x = TApplicationException()
1568 
      x.read(self._iprot)
1569 
      self._iprot.readMessageEnd()
1570 
      raise x
1571 
    result = getUserCommunicationByUser_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
3431 rajveer 1574 
    if result.success is not None:
1590 varun.gupt 1575 
      return result.success
3431 rajveer 1576 
    if result.ucx is not None:
1590 varun.gupt 1577 
      raise result.ucx
1578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1579 
 
1580 
  def getAllUserCommunications(self, ):
1581 
    self.send_getAllUserCommunications()
1582 
    return self.recv_getAllUserCommunications()
1583 
 
1584 
  def send_getAllUserCommunications(self, ):
1585 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1586 
    args = getAllUserCommunications_args()
1587 
    args.write(self._oprot)
1588 
    self._oprot.writeMessageEnd()
1589 
    self._oprot.trans.flush()
1590 
 
1591 
  def recv_getAllUserCommunications(self, ):
1592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1593 
    if mtype == TMessageType.EXCEPTION:
1594 
      x = TApplicationException()
1595 
      x.read(self._iprot)
1596 
      self._iprot.readMessageEnd()
1597 
      raise x
1598 
    result = getAllUserCommunications_result()
1599 
    result.read(self._iprot)
1600 
    self._iprot.readMessageEnd()
3431 rajveer 1601 
    if result.success is not None:
1590 varun.gupt 1602 
      return result.success
3431 rajveer 1603 
    if result.ucx is not None:
1590 varun.gupt 1604 
      raise result.ucx
1605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1606 
 
5407 amar.kumar 1607 
  def removeUserCommunication(self, id):
1608 
    """
1609 
    Parameters:
1610 
     - id
1611 
    """
1612 
    self.send_removeUserCommunication(id)
1613 
    self.recv_removeUserCommunication()
1614 
 
1615 
  def send_removeUserCommunication(self, id):
1616 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1617 
    args = removeUserCommunication_args()
1618 
    args.id = id
1619 
    args.write(self._oprot)
1620 
    self._oprot.writeMessageEnd()
1621 
    self._oprot.trans.flush()
1622 
 
1623 
  def recv_removeUserCommunication(self, ):
1624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1625 
    if mtype == TMessageType.EXCEPTION:
1626 
      x = TApplicationException()
1627 
      x.read(self._iprot)
1628 
      self._iprot.readMessageEnd()
1629 
      raise x
1630 
    result = removeUserCommunication_result()
1631 
    result.read(self._iprot)
1632 
    self._iprot.readMessageEnd()
1633 
    if result.ucx is not None:
1634 
      raise result.ucx
1635 
    return
1636 
 
1859 vikas 1637 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1638 
    """
1639 
    Parameters:
1640 
     - name
1859 vikas 1641 
     - addedOn
1845 vikas 1642 
    """
1859 vikas 1643 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1644 
    return self.recv_createMasterAffiliate()
1645 
 
1859 vikas 1646 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1647 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1648 
    args = createMasterAffiliate_args()
1649 
    args.name = name
1859 vikas 1650 
    args.addedOn = addedOn
1845 vikas 1651 
    args.write(self._oprot)
1652 
    self._oprot.writeMessageEnd()
1653 
    self._oprot.trans.flush()
1654 
 
1655 
  def recv_createMasterAffiliate(self, ):
1656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1657 
    if mtype == TMessageType.EXCEPTION:
1658 
      x = TApplicationException()
1659 
      x.read(self._iprot)
1660 
      self._iprot.readMessageEnd()
1661 
      raise x
1662 
    result = createMasterAffiliate_result()
1663 
    result.read(self._iprot)
1664 
    self._iprot.readMessageEnd()
3431 rajveer 1665 
    if result.success is not None:
1845 vikas 1666 
      return result.success
3431 rajveer 1667 
    if result.utx is not None:
1845 vikas 1668 
      raise result.utx
1669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1670 
 
1899 vikas 1671 
  def getAllMasterAffiliates(self, ):
1672 
    self.send_getAllMasterAffiliates()
1673 
    return self.recv_getAllMasterAffiliates()
1674 
 
1675 
  def send_getAllMasterAffiliates(self, ):
1676 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1677 
    args = getAllMasterAffiliates_args()
1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
1682 
  def recv_getAllMasterAffiliates(self, ):
1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
1689 
    result = getAllMasterAffiliates_result()
1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
3431 rajveer 1692 
    if result.success is not None:
1899 vikas 1693 
      return result.success
3431 rajveer 1694 
    if result.utx is not None:
1899 vikas 1695 
      raise result.utx
1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1697 
 
1845 vikas 1698 
  def getMasterAffiliateById(self, id):
1699 
    """
1700 
    Parameters:
1701 
     - id
1702 
    """
1703 
    self.send_getMasterAffiliateById(id)
1704 
    return self.recv_getMasterAffiliateById()
1705 
 
1706 
  def send_getMasterAffiliateById(self, id):
1707 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1708 
    args = getMasterAffiliateById_args()
1709 
    args.id = id
1710 
    args.write(self._oprot)
1711 
    self._oprot.writeMessageEnd()
1712 
    self._oprot.trans.flush()
1713 
 
1714 
  def recv_getMasterAffiliateById(self, ):
1715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1716 
    if mtype == TMessageType.EXCEPTION:
1717 
      x = TApplicationException()
1718 
      x.read(self._iprot)
1719 
      self._iprot.readMessageEnd()
1720 
      raise x
1721 
    result = getMasterAffiliateById_result()
1722 
    result.read(self._iprot)
1723 
    self._iprot.readMessageEnd()
3431 rajveer 1724 
    if result.success is not None:
1845 vikas 1725 
      return result.success
3431 rajveer 1726 
    if result.utx is not None:
1845 vikas 1727 
      raise result.utx
1728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1729 
 
1730 
  def getMasterAffiliateByName(self, name):
1731 
    """
1732 
    Parameters:
1733 
     - name
1734 
    """
1735 
    self.send_getMasterAffiliateByName(name)
1736 
    return self.recv_getMasterAffiliateByName()
1737 
 
1738 
  def send_getMasterAffiliateByName(self, name):
1739 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1740 
    args = getMasterAffiliateByName_args()
1741 
    args.name = name
1742 
    args.write(self._oprot)
1743 
    self._oprot.writeMessageEnd()
1744 
    self._oprot.trans.flush()
1745 
 
1746 
  def recv_getMasterAffiliateByName(self, ):
1747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1748 
    if mtype == TMessageType.EXCEPTION:
1749 
      x = TApplicationException()
1750 
      x.read(self._iprot)
1751 
      self._iprot.readMessageEnd()
1752 
      raise x
1753 
    result = getMasterAffiliateByName_result()
1754 
    result.read(self._iprot)
1755 
    self._iprot.readMessageEnd()
3431 rajveer 1756 
    if result.success is not None:
1845 vikas 1757 
      return result.success
3431 rajveer 1758 
    if result.utx is not None:
1845 vikas 1759 
      raise result.utx
1760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1761 
 
1859 vikas 1762 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1763 
    """
1764 
    Parameters:
1765 
     - name
1766 
     - url
1767 
     - masterAffiliateId
1859 vikas 1768 
     - addedOn
1845 vikas 1769 
    """
1859 vikas 1770 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1771 
    return self.recv_createAffiliate()
1772 
 
1859 vikas 1773 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1774 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1775 
    args = createAffiliate_args()
1776 
    args.name = name
1777 
    args.url = url
1778 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1779 
    args.addedOn = addedOn
1845 vikas 1780 
    args.write(self._oprot)
1781 
    self._oprot.writeMessageEnd()
1782 
    self._oprot.trans.flush()
1783 
 
1784 
  def recv_createAffiliate(self, ):
1785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1786 
    if mtype == TMessageType.EXCEPTION:
1787 
      x = TApplicationException()
1788 
      x.read(self._iprot)
1789 
      self._iprot.readMessageEnd()
1790 
      raise x
1791 
    result = createAffiliate_result()
1792 
    result.read(self._iprot)
1793 
    self._iprot.readMessageEnd()
3431 rajveer 1794 
    if result.success is not None:
1845 vikas 1795 
      return result.success
3431 rajveer 1796 
    if result.utx is not None:
1845 vikas 1797 
      raise result.utx
1798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1799 
 
1800 
  def getAffiliateById(self, id):
1801 
    """
1802 
    Parameters:
1803 
     - id
1804 
    """
1805 
    self.send_getAffiliateById(id)
1806 
    return self.recv_getAffiliateById()
1807 
 
1808 
  def send_getAffiliateById(self, id):
1809 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1810 
    args = getAffiliateById_args()
1811 
    args.id = id
1812 
    args.write(self._oprot)
1813 
    self._oprot.writeMessageEnd()
1814 
    self._oprot.trans.flush()
1815 
 
1816 
  def recv_getAffiliateById(self, ):
1817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1818 
    if mtype == TMessageType.EXCEPTION:
1819 
      x = TApplicationException()
1820 
      x.read(self._iprot)
1821 
      self._iprot.readMessageEnd()
1822 
      raise x
1823 
    result = getAffiliateById_result()
1824 
    result.read(self._iprot)
1825 
    self._iprot.readMessageEnd()
3431 rajveer 1826 
    if result.success is not None:
1845 vikas 1827 
      return result.success
3431 rajveer 1828 
    if result.utx is not None:
1845 vikas 1829 
      raise result.utx
1830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1831 
 
1832 
  def getAffiliateByName(self, name):
1833 
    """
1834 
    Parameters:
1835 
     - name
1836 
    """
1837 
    self.send_getAffiliateByName(name)
1838 
    return self.recv_getAffiliateByName()
1839 
 
1840 
  def send_getAffiliateByName(self, name):
1841 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1842 
    args = getAffiliateByName_args()
1843 
    args.name = name
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getAffiliateByName(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getAffiliateByName_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
3431 rajveer 1858 
    if result.success is not None:
1845 vikas 1859 
      return result.success
3431 rajveer 1860 
    if result.utx is not None:
1845 vikas 1861 
      raise result.utx
1862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1863 
 
1996 vikas 1864 
  def getTrackerById(self, id):
1845 vikas 1865 
    """
1866 
    Parameters:
1867 
     - id
1868 
    """
1996 vikas 1869 
    self.send_getTrackerById(id)
1845 vikas 1870 
    return self.recv_getTrackerById()
1871 
 
1996 vikas 1872 
  def send_getTrackerById(self, id):
1845 vikas 1873 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1874 
    args = getTrackerById_args()
1996 vikas 1875 
    args.id = id
1845 vikas 1876 
    args.write(self._oprot)
1877 
    self._oprot.writeMessageEnd()
1878 
    self._oprot.trans.flush()
1879 
 
1880 
  def recv_getTrackerById(self, ):
1881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1882 
    if mtype == TMessageType.EXCEPTION:
1883 
      x = TApplicationException()
1884 
      x.read(self._iprot)
1885 
      self._iprot.readMessageEnd()
1886 
      raise x
1887 
    result = getTrackerById_result()
1888 
    result.read(self._iprot)
1889 
    self._iprot.readMessageEnd()
3431 rajveer 1890 
    if result.success is not None:
1845 vikas 1891 
      return result.success
3431 rajveer 1892 
    if result.utx is not None:
1845 vikas 1893 
      raise result.utx
1894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1895 
 
1996 vikas 1896 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1897 
    """
1898 
    Parameters:
1996 vikas 1899 
     - id
1845 vikas 1900 
    """
1996 vikas 1901 
    self.send_getAffiliatesByMasterAffiliate(id)
1902 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1903 
 
1996 vikas 1904 
  def send_getAffiliatesByMasterAffiliate(self, id):
1905 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1906 
    args = getAffiliatesByMasterAffiliate_args()
1907 
    args.id = id
1845 vikas 1908 
    args.write(self._oprot)
1909 
    self._oprot.writeMessageEnd()
1910 
    self._oprot.trans.flush()
1911 
 
1996 vikas 1912 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1914 
    if mtype == TMessageType.EXCEPTION:
1915 
      x = TApplicationException()
1916 
      x.read(self._iprot)
1917 
      self._iprot.readMessageEnd()
1918 
      raise x
1996 vikas 1919 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1920 
    result.read(self._iprot)
1921 
    self._iprot.readMessageEnd()
3431 rajveer 1922 
    if result.success is not None:
1845 vikas 1923 
      return result.success
3431 rajveer 1924 
    if result.utx is not None:
1845 vikas 1925 
      raise result.utx
1996 vikas 1926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1927 
 
1996 vikas 1928 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1929 
    """
1930 
    Parameters:
1996 vikas 1931 
     - affiliateId
1845 vikas 1932 
     - userId
1933 
     - event
1934 
     - url
1935 
     - data
1859 vikas 1936 
     - addedOn
1845 vikas 1937 
    """
1996 vikas 1938 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1939 
    return self.recv_addTrackLog()
1940 
 
1996 vikas 1941 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1942 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1943 
    args = addTrackLog_args()
1996 vikas 1944 
    args.affiliateId = affiliateId
1845 vikas 1945 
    args.userId = userId
1946 
    args.event = event
1947 
    args.url = url
1948 
    args.data = data
1859 vikas 1949 
    args.addedOn = addedOn
1845 vikas 1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
1954 
  def recv_addTrackLog(self, ):
1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
1961 
    result = addTrackLog_result()
1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
3431 rajveer 1964 
    if result.success is not None:
1845 vikas 1965 
      return result.success
3431 rajveer 1966 
    if result.utx is not None:
1845 vikas 1967 
      raise result.utx
1968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1969 
 
1970 
  def getTrackLogById(self, id):
1971 
    """
1972 
    Parameters:
1973 
     - id
1974 
    """
1975 
    self.send_getTrackLogById(id)
1976 
    return self.recv_getTrackLogById()
1977 
 
1978 
  def send_getTrackLogById(self, id):
1979 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1980 
    args = getTrackLogById_args()
1981 
    args.id = id
1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
1986 
  def recv_getTrackLogById(self, ):
1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
1993 
    result = getTrackLogById_result()
1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
3431 rajveer 1996 
    if result.success is not None:
1845 vikas 1997 
      return result.success
3431 rajveer 1998 
    if result.utx is not None:
1845 vikas 1999 
      raise result.utx
2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
2001 
 
3293 vikas 2002 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 2003 
    """
2004 
    Parameters:
1996 vikas 2005 
     - affiliateId
3293 vikas 2006 
     - startDate
2007 
     - endDate
1845 vikas 2008 
    """
3293 vikas 2009 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2010 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2011 
 
3293 vikas 2012 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2013 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2014 
    args = getTrackLogsByAffiliate_args()
2015 
    args.affiliateId = affiliateId
3293 vikas 2016 
    args.startDate = startDate
2017 
    args.endDate = endDate
1845 vikas 2018 
    args.write(self._oprot)
2019 
    self._oprot.writeMessageEnd()
2020 
    self._oprot.trans.flush()
2021 
 
1996 vikas 2022 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2024 
    if mtype == TMessageType.EXCEPTION:
2025 
      x = TApplicationException()
2026 
      x.read(self._iprot)
2027 
      self._iprot.readMessageEnd()
2028 
      raise x
1996 vikas 2029 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2030 
    result.read(self._iprot)
2031 
    self._iprot.readMessageEnd()
3431 rajveer 2032 
    if result.success is not None:
1845 vikas 2033 
      return result.success
3431 rajveer 2034 
    if result.utx is not None:
1845 vikas 2035 
      raise result.utx
1996 vikas 2036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2037 
 
2038 
  def getTrackLogsByUser(self, userId):
2039 
    """
2040 
    Parameters:
2041 
     - userId
2042 
    """
2043 
    self.send_getTrackLogsByUser(userId)
2044 
    return self.recv_getTrackLogsByUser()
2045 
 
2046 
  def send_getTrackLogsByUser(self, userId):
2047 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2048 
    args = getTrackLogsByUser_args()
2049 
    args.userId = userId
2050 
    args.write(self._oprot)
2051 
    self._oprot.writeMessageEnd()
2052 
    self._oprot.trans.flush()
2053 
 
2054 
  def recv_getTrackLogsByUser(self, ):
2055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2056 
    if mtype == TMessageType.EXCEPTION:
2057 
      x = TApplicationException()
2058 
      x.read(self._iprot)
2059 
      self._iprot.readMessageEnd()
2060 
      raise x
2061 
    result = getTrackLogsByUser_result()
2062 
    result.read(self._iprot)
2063 
    self._iprot.readMessageEnd()
3431 rajveer 2064 
    if result.success is not None:
1845 vikas 2065 
      return result.success
3431 rajveer 2066 
    if result.utx is not None:
1845 vikas 2067 
      raise result.utx
2068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2069 
 
1996 vikas 2070 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2071 
    """
2072 
    Parameters:
2073 
     - userId
2074 
     - event
2075 
     - url
2076 
    """
1996 vikas 2077 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2078 
    return self.recv_getTrackLogs()
2079 
 
1996 vikas 2080 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2081 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2082 
    args = getTrackLogs_args()
2083 
    args.userId = userId
2084 
    args.event = event
2085 
    args.url = url
2086 
    args.write(self._oprot)
2087 
    self._oprot.writeMessageEnd()
2088 
    self._oprot.trans.flush()
2089 
 
2090 
  def recv_getTrackLogs(self, ):
2091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2092 
    if mtype == TMessageType.EXCEPTION:
2093 
      x = TApplicationException()
2094 
      x.read(self._iprot)
2095 
      self._iprot.readMessageEnd()
2096 
      raise x
2097 
    result = getTrackLogs_result()
2098 
    result.read(self._iprot)
2099 
    self._iprot.readMessageEnd()
3431 rajveer 2100 
    if result.success is not None:
1845 vikas 2101 
      return result.success
3431 rajveer 2102 
    if result.utx is not None:
1845 vikas 2103 
      raise result.utx
2104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2105 
 
559 chandransh 2106 
  def getCurrentCart(self, userId):
94 ashish 2107 
    """
2108 
    Parameters:
559 chandransh 2109 
     - userId
94 ashish 2110 
    """
559 chandransh 2111 
    self.send_getCurrentCart(userId)
2112 
    return self.recv_getCurrentCart()
94 ashish 2113 
 
559 chandransh 2114 
  def send_getCurrentCart(self, userId):
2115 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2116 
    args = getCurrentCart_args()
2117 
    args.userId = userId
94 ashish 2118 
    args.write(self._oprot)
2119 
    self._oprot.writeMessageEnd()
2120 
    self._oprot.trans.flush()
2121 
 
559 chandransh 2122 
  def recv_getCurrentCart(self, ):
94 ashish 2123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2124 
    if mtype == TMessageType.EXCEPTION:
2125 
      x = TApplicationException()
2126 
      x.read(self._iprot)
2127 
      self._iprot.readMessageEnd()
2128 
      raise x
559 chandransh 2129 
    result = getCurrentCart_result()
94 ashish 2130 
    result.read(self._iprot)
2131 
    self._iprot.readMessageEnd()
3431 rajveer 2132 
    if result.success is not None:
94 ashish 2133 
      return result.success
3431 rajveer 2134 
    if result.scx is not None:
559 chandransh 2135 
      raise result.scx
2136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2137 
 
559 chandransh 2138 
  def getCart(self, cartId):
94 ashish 2139 
    """
2140 
    Parameters:
559 chandransh 2141 
     - cartId
94 ashish 2142 
    """
559 chandransh 2143 
    self.send_getCart(cartId)
2144 
    return self.recv_getCart()
94 ashish 2145 
 
559 chandransh 2146 
  def send_getCart(self, cartId):
2147 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2148 
    args = getCart_args()
2149 
    args.cartId = cartId
94 ashish 2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
559 chandransh 2154 
  def recv_getCart(self, ):
94 ashish 2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
559 chandransh 2161 
    result = getCart_result()
94 ashish 2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
3431 rajveer 2164 
    if result.success is not None:
94 ashish 2165 
      return result.success
3431 rajveer 2166 
    if result.scx is not None:
559 chandransh 2167 
      raise result.scx
2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2169 
 
559 chandransh 2170 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2171 
    """
2172 
    Parameters:
559 chandransh 2173 
     - from_time
2174 
     - to_time
2175 
     - status
94 ashish 2176 
    """
559 chandransh 2177 
    self.send_getCartsByTime(from_time, to_time, status)
2178 
    return self.recv_getCartsByTime()
94 ashish 2179 
 
559 chandransh 2180 
  def send_getCartsByTime(self, from_time, to_time, status):
2181 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2182 
    args = getCartsByTime_args()
2183 
    args.from_time = from_time
2184 
    args.to_time = to_time
2185 
    args.status = status
94 ashish 2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
559 chandransh 2190 
  def recv_getCartsByTime(self, ):
94 ashish 2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
559 chandransh 2197 
    result = getCartsByTime_result()
94 ashish 2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
3431 rajveer 2200 
    if result.success is not None:
94 ashish 2201 
      return result.success
3431 rajveer 2202 
    if result.scx is not None:
559 chandransh 2203 
      raise result.scx
2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2205 
 
3557 rajveer 2206 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2207 
    """
2208 
    Parameters:
2209 
     - cartId
2210 
     - itemId
2211 
     - quantity
3557 rajveer 2212 
     - sourceId
559 chandransh 2213 
    """
3557 rajveer 2214 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2215 
    return self.recv_addItemToCart()
559 chandransh 2216 
 
3557 rajveer 2217 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2218 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2219 
    args = addItemToCart_args()
2220 
    args.cartId = cartId
2221 
    args.itemId = itemId
2222 
    args.quantity = quantity
3557 rajveer 2223 
    args.sourceId = sourceId
559 chandransh 2224 
    args.write(self._oprot)
2225 
    self._oprot.writeMessageEnd()
2226 
    self._oprot.trans.flush()
2227 
 
2228 
  def recv_addItemToCart(self, ):
2229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2230 
    if mtype == TMessageType.EXCEPTION:
2231 
      x = TApplicationException()
2232 
      x.read(self._iprot)
2233 
      self._iprot.readMessageEnd()
2234 
      raise x
2235 
    result = addItemToCart_result()
2236 
    result.read(self._iprot)
2237 
    self._iprot.readMessageEnd()
3431 rajveer 2238 
    if result.success is not None:
2035 rajveer 2239 
      return result.success
3431 rajveer 2240 
    if result.scx is not None:
559 chandransh 2241 
      raise result.scx
2035 rajveer 2242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2243 
 
2244 
  def deleteItemFromCart(self, cartId, itemId):
2245 
    """
2246 
    Parameters:
2247 
     - cartId
2248 
     - itemId
2249 
    """
2250 
    self.send_deleteItemFromCart(cartId, itemId)
2251 
    self.recv_deleteItemFromCart()
2252 
 
2253 
  def send_deleteItemFromCart(self, cartId, itemId):
2254 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2255 
    args = deleteItemFromCart_args()
2256 
    args.cartId = cartId
2257 
    args.itemId = itemId
2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_deleteItemFromCart(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = deleteItemFromCart_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
3431 rajveer 2272 
    if result.scx is not None:
559 chandransh 2273 
      raise result.scx
2274 
    return
2275 
 
2276 
  def addAddressToCart(self, cartId, addressId):
2277 
    """
2278 
    Parameters:
2279 
     - cartId
2280 
     - addressId
2281 
    """
2282 
    self.send_addAddressToCart(cartId, addressId)
2283 
    self.recv_addAddressToCart()
2284 
 
2285 
  def send_addAddressToCart(self, cartId, addressId):
2286 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2287 
    args = addAddressToCart_args()
2288 
    args.cartId = cartId
2289 
    args.addressId = addressId
2290 
    args.write(self._oprot)
2291 
    self._oprot.writeMessageEnd()
2292 
    self._oprot.trans.flush()
2293 
 
2294 
  def recv_addAddressToCart(self, ):
2295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2296 
    if mtype == TMessageType.EXCEPTION:
2297 
      x = TApplicationException()
2298 
      x.read(self._iprot)
2299 
      self._iprot.readMessageEnd()
2300 
      raise x
2301 
    result = addAddressToCart_result()
2302 
    result.read(self._iprot)
2303 
    self._iprot.readMessageEnd()
3431 rajveer 2304 
    if result.scx is not None:
575 chandransh 2305 
      raise result.scx
559 chandransh 2306 
    return
2307 
 
5553 rajveer 2308 
  def addStoreToCart(self, cartId, storeId):
2309 
    """
2310 
    Parameters:
2311 
     - cartId
2312 
     - storeId
2313 
    """
2314 
    self.send_addStoreToCart(cartId, storeId)
2315 
    self.recv_addStoreToCart()
2316 
 
2317 
  def send_addStoreToCart(self, cartId, storeId):
2318 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2319 
    args = addStoreToCart_args()
2320 
    args.cartId = cartId
2321 
    args.storeId = storeId
2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
2326 
  def recv_addStoreToCart(self, ):
2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
2333 
    result = addStoreToCart_result()
2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
2336 
    if result.scx is not None:
2337 
      raise result.scx
2338 
    return
2339 
 
6922 anupam.sin 2340 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2341 
    """
2342 
    Parameters:
6922 anupam.sin 2343 
     - cart
1976 varun.gupt 2344 
     - couponCode
2345 
    """
6922 anupam.sin 2346 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2347 
    self.recv_applyCouponToCart()
2348 
 
6922 anupam.sin 2349 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2350 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2351 
    args = applyCouponToCart_args()
6922 anupam.sin 2352 
    args.cart = cart
1976 varun.gupt 2353 
    args.couponCode = couponCode
2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
2358 
  def recv_applyCouponToCart(self, ):
2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
2365 
    result = applyCouponToCart_result()
2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
3431 rajveer 2368 
    if result.scx is not None:
1976 varun.gupt 2369 
      raise result.scx
2370 
    return
2371 
 
2372 
  def removeCoupon(self, cartId):
2373 
    """
2374 
    Parameters:
2375 
     - cartId
2376 
    """
2377 
    self.send_removeCoupon(cartId)
2378 
    self.recv_removeCoupon()
2379 
 
2380 
  def send_removeCoupon(self, cartId):
2381 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2382 
    args = removeCoupon_args()
2383 
    args.cartId = cartId
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_removeCoupon(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = removeCoupon_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.scx is not None:
1976 varun.gupt 2399 
      raise result.scx
2400 
    return
2401 
 
3554 varun.gupt 2402 
  def deleteDiscountsFromCart(self, cartId):
2403 
    """
2404 
    Deletes all the discounts associated with the cart
2405 
 
2406 
    Parameters:
2407 
     - cartId
2408 
    """
2409 
    self.send_deleteDiscountsFromCart(cartId)
2410 
    self.recv_deleteDiscountsFromCart()
2411 
 
2412 
  def send_deleteDiscountsFromCart(self, cartId):
2413 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2414 
    args = deleteDiscountsFromCart_args()
2415 
    args.cartId = cartId
2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
2420 
  def recv_deleteDiscountsFromCart(self, ):
2421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2422 
    if mtype == TMessageType.EXCEPTION:
2423 
      x = TApplicationException()
2424 
      x.read(self._iprot)
2425 
      self._iprot.readMessageEnd()
2426 
      raise x
2427 
    result = deleteDiscountsFromCart_result()
2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
2430 
    if result.scx is not None:
2431 
      raise result.scx
2432 
    return
2433 
 
2434 
  def saveDiscounts(self, discounts):
2435 
    """
2436 
    Accepts a list of thrift objects of Discount type and saves them
2437 
 
2438 
    Parameters:
2439 
     - discounts
2440 
    """
2441 
    self.send_saveDiscounts(discounts)
2442 
    self.recv_saveDiscounts()
2443 
 
2444 
  def send_saveDiscounts(self, discounts):
2445 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2446 
    args = saveDiscounts_args()
2447 
    args.discounts = discounts
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_saveDiscounts(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = saveDiscounts_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
2462 
    if result.scx is not None:
2463 
      raise result.scx
2464 
    return
2465 
 
11526 amit.gupta 2466 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2467 
    """
690 chandransh 2468 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2469 
 
559 chandransh 2470 
    Parameters:
2471 
     - cartId
2815 vikas 2472 
     - sessionSource
2473 
     - sessionStartTime
3858 vikas 2474 
     - firstSource
2475 
     - firstSourceTime
5326 rajveer 2476 
     - userId
6389 rajveer 2477 
     - schemeId
11526 amit.gupta 2478 
     - orderSource
559 chandransh 2479 
    """
11526 amit.gupta 2480 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2481 
    return self.recv_createOrders()
559 chandransh 2482 
 
11526 amit.gupta 2483 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2484 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2485 
    args = createOrders_args()
559 chandransh 2486 
    args.cartId = cartId
2815 vikas 2487 
    args.sessionSource = sessionSource
2488 
    args.sessionStartTime = sessionStartTime
3858 vikas 2489 
    args.firstSource = firstSource
2490 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2491 
    args.userId = userId
6389 rajveer 2492 
    args.schemeId = schemeId
11526 amit.gupta 2493 
    args.orderSource = orderSource
559 chandransh 2494 
    args.write(self._oprot)
2495 
    self._oprot.writeMessageEnd()
2496 
    self._oprot.trans.flush()
2497 
 
690 chandransh 2498 
  def recv_createOrders(self, ):
559 chandransh 2499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2500 
    if mtype == TMessageType.EXCEPTION:
2501 
      x = TApplicationException()
2502 
      x.read(self._iprot)
2503 
      self._iprot.readMessageEnd()
2504 
      raise x
690 chandransh 2505 
    result = createOrders_result()
559 chandransh 2506 
    result.read(self._iprot)
2507 
    self._iprot.readMessageEnd()
3431 rajveer 2508 
    if result.success is not None:
130 ashish 2509 
      return result.success
3431 rajveer 2510 
    if result.scx is not None:
559 chandransh 2511 
      raise result.scx
690 chandransh 2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2513 
 
3557 rajveer 2514 
  def validateCart(self, cartId, sourceId):
130 ashish 2515 
    """
690 chandransh 2516 
    Validates that:
2517 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2518 
    2. All of the lines in the cart are active items.
690 chandransh 2519 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2520 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2521 
 
130 ashish 2522 
    Parameters:
559 chandransh 2523 
     - cartId
3557 rajveer 2524 
     - sourceId
130 ashish 2525 
    """
3557 rajveer 2526 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2527 
    return self.recv_validateCart()
130 ashish 2528 
 
3557 rajveer 2529 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2530 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2531 
    args = validateCart_args()
2532 
    args.cartId = cartId
3557 rajveer 2533 
    args.sourceId = sourceId
130 ashish 2534 
    args.write(self._oprot)
2535 
    self._oprot.writeMessageEnd()
2536 
    self._oprot.trans.flush()
2537 
 
559 chandransh 2538 
  def recv_validateCart(self, ):
130 ashish 2539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2540 
    if mtype == TMessageType.EXCEPTION:
2541 
      x = TApplicationException()
2542 
      x.read(self._iprot)
2543 
      self._iprot.readMessageEnd()
2544 
      raise x
559 chandransh 2545 
    result = validateCart_result()
130 ashish 2546 
    result.read(self._iprot)
2547 
    self._iprot.readMessageEnd()
3431 rajveer 2548 
    if result.success is not None:
130 ashish 2549 
      return result.success
3431 rajveer 2550 
    if result.scex is not None:
575 chandransh 2551 
      raise result.scex
559 chandransh 2552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2553 
 
11980 amit.gupta 2554 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2555 
    """
2556 
    Validates that:
2557 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2558 
    2. All of the lines in the cart are active items.
2559 
    3. The estimate for any of the lines in cart doesn't change.
2560 
    If all three are true, returns empty string; else returns appropriate message.
2561 
 
2562 
    Parameters:
2563 
     - cartId
2564 
     - sourceId
2565 
     - dealCoupon
2566 
    """
2567 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2568 
    return self.recv_validateCartWithDealerCoupon()
2569 
 
2570 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2571 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2572 
    args = validateCartWithDealerCoupon_args()
2573 
    args.cartId = cartId
2574 
    args.sourceId = sourceId
2575 
    args.dealCoupon = dealCoupon
2576 
    args.write(self._oprot)
2577 
    self._oprot.writeMessageEnd()
2578 
    self._oprot.trans.flush()
2579 
 
2580 
  def recv_validateCartWithDealerCoupon(self, ):
2581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2582 
    if mtype == TMessageType.EXCEPTION:
2583 
      x = TApplicationException()
2584 
      x.read(self._iprot)
2585 
      self._iprot.readMessageEnd()
2586 
      raise x
2587 
    result = validateCartWithDealerCoupon_result()
2588 
    result.read(self._iprot)
2589 
    self._iprot.readMessageEnd()
2590 
    if result.success is not None:
2591 
      return result.success
2592 
    if result.scex is not None:
2593 
      raise result.scex
2594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2595 
 
690 chandransh 2596 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2597 
    """
690 chandransh 2598 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2599 
 
575 chandransh 2600 
    Parameters:
690 chandransh 2601 
     - fromCartId
2602 
     - toCartId
2603 
    """
2604 
    self.send_mergeCart(fromCartId, toCartId)
2605 
    self.recv_mergeCart()
2606 
 
2607 
  def send_mergeCart(self, fromCartId, toCartId):
2608 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2609 
    args = mergeCart_args()
2610 
    args.fromCartId = fromCartId
2611 
    args.toCartId = toCartId
2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
2616 
  def recv_mergeCart(self, ):
2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
2623 
    result = mergeCart_result()
2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
2626 
    return
2627 
 
2628 
  def checkOut(self, cartId):
2629 
    """
2630 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2631 
 
690 chandransh 2632 
    Parameters:
575 chandransh 2633 
     - cartId
2634 
    """
690 chandransh 2635 
    self.send_checkOut(cartId)
2636 
    return self.recv_checkOut()
575 chandransh 2637 
 
690 chandransh 2638 
  def send_checkOut(self, cartId):
2639 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2640 
    args = checkOut_args()
575 chandransh 2641 
    args.cartId = cartId
2642 
    args.write(self._oprot)
2643 
    self._oprot.writeMessageEnd()
2644 
    self._oprot.trans.flush()
2645 
 
690 chandransh 2646 
  def recv_checkOut(self, ):
575 chandransh 2647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2648 
    if mtype == TMessageType.EXCEPTION:
2649 
      x = TApplicationException()
2650 
      x.read(self._iprot)
2651 
      self._iprot.readMessageEnd()
2652 
      raise x
690 chandransh 2653 
    result = checkOut_result()
575 chandransh 2654 
    result.read(self._iprot)
2655 
    self._iprot.readMessageEnd()
3431 rajveer 2656 
    if result.success is not None:
575 chandransh 2657 
      return result.success
3431 rajveer 2658 
    if result.scex is not None:
575 chandransh 2659 
      raise result.scex
690 chandransh 2660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2661 
 
690 chandransh 2662 
  def resetCart(self, cartId, items):
559 chandransh 2663 
    """
690 chandransh 2664 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2665 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2666 
 
559 chandransh 2667 
    Parameters:
690 chandransh 2668 
     - cartId
2669 
     - items
559 chandransh 2670 
    """
690 chandransh 2671 
    self.send_resetCart(cartId, items)
2672 
    return self.recv_resetCart()
130 ashish 2673 
 
690 chandransh 2674 
  def send_resetCart(self, cartId, items):
2675 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2676 
    args = resetCart_args()
2677 
    args.cartId = cartId
2678 
    args.items = items
559 chandransh 2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
690 chandransh 2683 
  def recv_resetCart(self, ):
559 chandransh 2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
690 chandransh 2690 
    result = resetCart_result()
559 chandransh 2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
3431 rajveer 2693 
    if result.success is not None:
690 chandransh 2694 
      return result.success
3431 rajveer 2695 
    if result.scex is not None:
690 chandransh 2696 
      raise result.scex
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2698 
 
2981 rajveer 2699 
  def getUserCount(self, userType):
559 chandransh 2700 
    """
2981 rajveer 2701 
    Returns number of registered users.
2702 
    If userType = null, then it returns count of all users, including anonymous
2703 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2704 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2705 
 
559 chandransh 2706 
    Parameters:
2981 rajveer 2707 
     - userType
559 chandransh 2708 
    """
2981 rajveer 2709 
    self.send_getUserCount(userType)
2710 
    return self.recv_getUserCount()
559 chandransh 2711 
 
2981 rajveer 2712 
  def send_getUserCount(self, userType):
2713 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2714 
    args = getUserCount_args()
2715 
    args.userType = userType
559 chandransh 2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2981 rajveer 2720 
  def recv_getUserCount(self, ):
559 chandransh 2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2981 rajveer 2727 
    result = getUserCount_result()
559 chandransh 2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
3431 rajveer 2730 
    if result.success is not None:
559 chandransh 2731 
      return result.success
2981 rajveer 2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2733 
 
2981 rajveer 2734 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2735 
    """
2981 rajveer 2736 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2737 
    If any of startDate or endDate is -1, then that filter is ignored.
2738 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2739 
 
2740 
 
559 chandransh 2741 
    Parameters:
2981 rajveer 2742 
     - userType
2743 
     - startDate
2744 
     - endDate
559 chandransh 2745 
    """
2981 rajveer 2746 
    self.send_getAllUsers(userType, startDate, endDate)
2747 
    return self.recv_getAllUsers()
559 chandransh 2748 
 
2981 rajveer 2749 
  def send_getAllUsers(self, userType, startDate, endDate):
2750 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2751 
    args = getAllUsers_args()
2752 
    args.userType = userType
2753 
    args.startDate = startDate
2754 
    args.endDate = endDate
559 chandransh 2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
2981 rajveer 2759 
  def recv_getAllUsers(self, ):
559 chandransh 2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
2981 rajveer 2766 
    result = getAllUsers_result()
559 chandransh 2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
3431 rajveer 2769 
    if result.success is not None:
559 chandransh 2770 
      return result.success
2981 rajveer 2771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2772 
 
2981 rajveer 2773 
  def getMyResearchItems(self, userId):
559 chandransh 2774 
    """
2981 rajveer 2775 
    Returns list of item ids in myresearch for the user
3431 rajveer 2776 
 
559 chandransh 2777 
    Parameters:
772 rajveer 2778 
     - userId
559 chandransh 2779 
    """
2981 rajveer 2780 
    self.send_getMyResearchItems(userId)
2781 
    return self.recv_getMyResearchItems()
559 chandransh 2782 
 
2981 rajveer 2783 
  def send_getMyResearchItems(self, userId):
2784 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2785 
    args = getMyResearchItems_args()
772 rajveer 2786 
    args.userId = userId
559 chandransh 2787 
    args.write(self._oprot)
2788 
    self._oprot.writeMessageEnd()
2789 
    self._oprot.trans.flush()
2790 
 
2981 rajveer 2791 
  def recv_getMyResearchItems(self, ):
559 chandransh 2792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2793 
    if mtype == TMessageType.EXCEPTION:
2794 
      x = TApplicationException()
2795 
      x.read(self._iprot)
2796 
      self._iprot.readMessageEnd()
2797 
      raise x
2981 rajveer 2798 
    result = getMyResearchItems_result()
559 chandransh 2799 
    result.read(self._iprot)
2800 
    self._iprot.readMessageEnd()
3431 rajveer 2801 
    if result.success is not None:
559 chandransh 2802 
      return result.success
3431 rajveer 2803 
    if result.scx is not None:
559 chandransh 2804 
      raise result.scx
2981 rajveer 2805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2806 
 
2981 rajveer 2807 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2808 
    """
2981 rajveer 2809 
    add item to my research for a user
3431 rajveer 2810 
 
559 chandransh 2811 
    Parameters:
2981 rajveer 2812 
     - userId
2813 
     - itemId
559 chandransh 2814 
    """
2981 rajveer 2815 
    self.send_updateMyResearch(userId, itemId)
2816 
    return self.recv_updateMyResearch()
559 chandransh 2817 
 
2981 rajveer 2818 
  def send_updateMyResearch(self, userId, itemId):
2819 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2820 
    args = updateMyResearch_args()
2821 
    args.userId = userId
2822 
    args.itemId = itemId
559 chandransh 2823 
    args.write(self._oprot)
2824 
    self._oprot.writeMessageEnd()
2825 
    self._oprot.trans.flush()
2826 
 
2981 rajveer 2827 
  def recv_updateMyResearch(self, ):
559 chandransh 2828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2829 
    if mtype == TMessageType.EXCEPTION:
2830 
      x = TApplicationException()
2831 
      x.read(self._iprot)
2832 
      self._iprot.readMessageEnd()
2833 
      raise x
2981 rajveer 2834 
    result = updateMyResearch_result()
559 chandransh 2835 
    result.read(self._iprot)
2836 
    self._iprot.readMessageEnd()
3431 rajveer 2837 
    if result.success is not None:
2981 rajveer 2838 
      return result.success
3431 rajveer 2839 
    if result.scx is not None:
2981 rajveer 2840 
      raise result.scx
2841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2842 
 
2981 rajveer 2843 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2844 
    """
2981 rajveer 2845 
    delete item from my research for a user
3431 rajveer 2846 
 
1596 ankur.sing 2847 
    Parameters:
2981 rajveer 2848 
     - userId
2849 
     - itemId
1596 ankur.sing 2850 
    """
2981 rajveer 2851 
    self.send_deleteItemFromMyResearch(userId, itemId)
2852 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2853 
 
2981 rajveer 2854 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2855 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2856 
    args = deleteItemFromMyResearch_args()
2857 
    args.userId = userId
2858 
    args.itemId = itemId
1596 ankur.sing 2859 
    args.write(self._oprot)
2860 
    self._oprot.writeMessageEnd()
2861 
    self._oprot.trans.flush()
2862 
 
2981 rajveer 2863 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2865 
    if mtype == TMessageType.EXCEPTION:
2866 
      x = TApplicationException()
2867 
      x.read(self._iprot)
2868 
      self._iprot.readMessageEnd()
2869 
      raise x
2981 rajveer 2870 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2871 
    result.read(self._iprot)
2872 
    self._iprot.readMessageEnd()
3431 rajveer 2873 
    if result.scx is not None:
2981 rajveer 2874 
      raise result.scx
2875 
    return
1596 ankur.sing 2876 
 
2981 rajveer 2877 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2878 
    """
2981 rajveer 2879 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2880 
 
1673 ankur.sing 2881 
    Parameters:
2981 rajveer 2882 
     - userId
1673 ankur.sing 2883 
    """
2981 rajveer 2884 
    self.send_getBrowseHistoryItems(userId)
2885 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2886 
 
2981 rajveer 2887 
  def send_getBrowseHistoryItems(self, userId):
2888 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2889 
    args = getBrowseHistoryItems_args()
2890 
    args.userId = userId
1673 ankur.sing 2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2981 rajveer 2895 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2981 rajveer 2902 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
3431 rajveer 2905 
    if result.success is not None:
1673 ankur.sing 2906 
      return result.success
3431 rajveer 2907 
    if result.scx is not None:
2981 rajveer 2908 
      raise result.scx
2909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2910 
 
2981 rajveer 2911 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2912 
    """
2981 rajveer 2913 
    add item to browse history for a user
3431 rajveer 2914 
 
2642 varun.gupt 2915 
    Parameters:
2981 rajveer 2916 
     - userId
2917 
     - itemId
2642 varun.gupt 2918 
    """
2981 rajveer 2919 
    self.send_updateBrowseHistory(userId, itemId)
2920 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2921 
 
2981 rajveer 2922 
  def send_updateBrowseHistory(self, userId, itemId):
2923 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2924 
    args = updateBrowseHistory_args()
2925 
    args.userId = userId
2926 
    args.itemId = itemId
2642 varun.gupt 2927 
    args.write(self._oprot)
2928 
    self._oprot.writeMessageEnd()
2929 
    self._oprot.trans.flush()
2930 
 
2981 rajveer 2931 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2933 
    if mtype == TMessageType.EXCEPTION:
2934 
      x = TApplicationException()
2935 
      x.read(self._iprot)
2936 
      self._iprot.readMessageEnd()
2937 
      raise x
2981 rajveer 2938 
    result = updateBrowseHistory_result()
2642 varun.gupt 2939 
    result.read(self._iprot)
2940 
    self._iprot.readMessageEnd()
2941 
    return
2942 
 
3385 varun.gupt 2943 
  def getCartsWithCouponCount(self, couponCode):
2944 
    """
2945 
    Returns count of Carts with given coupon applied
3431 rajveer 2946 
 
3385 varun.gupt 2947 
    Parameters:
2948 
     - couponCode
2949 
    """
2950 
    self.send_getCartsWithCouponCount(couponCode)
2951 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2952 
 
3385 varun.gupt 2953 
  def send_getCartsWithCouponCount(self, couponCode):
2954 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2955 
    args = getCartsWithCouponCount_args()
2956 
    args.couponCode = couponCode
2957 
    args.write(self._oprot)
2958 
    self._oprot.writeMessageEnd()
2959 
    self._oprot.trans.flush()
2960 
 
2961 
  def recv_getCartsWithCouponCount(self, ):
2962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2963 
    if mtype == TMessageType.EXCEPTION:
2964 
      x = TApplicationException()
2965 
      x.read(self._iprot)
2966 
      self._iprot.readMessageEnd()
2967 
      raise x
2968 
    result = getCartsWithCouponCount_result()
2969 
    result.read(self._iprot)
2970 
    self._iprot.readMessageEnd()
3431 rajveer 2971 
    if result.success is not None:
3385 varun.gupt 2972 
      return result.success
2973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2974 
 
3499 mandeep.dh 2975 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2976 
    """
2977 
    Updates COD trust level of a user
3385 varun.gupt 2978 
 
3499 mandeep.dh 2979 
    Parameters:
2980 
     - userId
2981 
     - trustLevelDelta
2982 
    """
2983 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2984 
 
2985 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2986 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2987 
    args = increaseTrustLevel_args()
2988 
    args.userId = userId
2989 
    args.trustLevelDelta = trustLevelDelta
2990 
    args.write(self._oprot)
2991 
    self._oprot.writeMessageEnd()
2992 
    self._oprot.trans.flush()
5407 amar.kumar 2993 
  def getTrustLevel(self, userId):
2994 
    """
2995 
    Get trust level of a user
2996 
 
2997 
    Parameters:
2998 
     - userId
2999 
    """
3000 
    self.send_getTrustLevel(userId)
3001 
    return self.recv_getTrustLevel()
3002 
 
3003 
  def send_getTrustLevel(self, userId):
3004 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
3005 
    args = getTrustLevel_args()
3006 
    args.userId = userId
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_getTrustLevel(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = getTrustLevel_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3024 
 
4668 varun.gupt 3025 
  def showCODOption(self, cartId, sourceId, pincode):
3026 
    """
3027 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3028 
 
4668 varun.gupt 3029 
    Parameters:
3030 
     - cartId
3031 
     - sourceId
3032 
     - pincode
3033 
    """
3034 
    self.send_showCODOption(cartId, sourceId, pincode)
3035 
    return self.recv_showCODOption()
3036 
 
3037 
  def send_showCODOption(self, cartId, sourceId, pincode):
3038 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3039 
    args = showCODOption_args()
3040 
    args.cartId = cartId
3041 
    args.sourceId = sourceId
3042 
    args.pincode = pincode
3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
3047 
  def recv_showCODOption(self, ):
3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
3054 
    result = showCODOption_result()
3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3057 
    if result.success is not None:
3058 
      return result.success
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3060 
 
5623 anupam.sin 3061 
  def getUserEmails(self, startDate, endDate):
3062 
    """
3063 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3064 
 
5623 anupam.sin 3065 
    Parameters:
3066 
     - startDate
3067 
     - endDate
3068 
    """
3069 
    self.send_getUserEmails(startDate, endDate)
3070 
    return self.recv_getUserEmails()
3071 
 
3072 
  def send_getUserEmails(self, startDate, endDate):
3073 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3074 
    args = getUserEmails_args()
3075 
    args.startDate = startDate
3076 
    args.endDate = endDate
3077 
    args.write(self._oprot)
3078 
    self._oprot.writeMessageEnd()
3079 
    self._oprot.trans.flush()
3080 
 
3081 
  def recv_getUserEmails(self, ):
3082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3083 
    if mtype == TMessageType.EXCEPTION:
3084 
      x = TApplicationException()
3085 
      x.read(self._iprot)
3086 
      self._iprot.readMessageEnd()
3087 
      raise x
3088 
    result = getUserEmails_result()
3089 
    result.read(self._iprot)
3090 
    self._iprot.readMessageEnd()
3091 
    if result.success is not None:
3092 
      return result.success
3093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3094 
 
9299 kshitij.so 3095 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3096 
    """
3097 
    Mark a cart lineitem as insured. Returns true/false.
3098 
 
3099 
    Parameters:
3100 
     - itemId
3101 
     - cartId
3102 
     - toInsure
9299 kshitij.so 3103 
     - insurerType
6903 anupam.sin 3104 
    """
9299 kshitij.so 3105 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3106 
    return self.recv_insureItem()
3107 
 
9299 kshitij.so 3108 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3109 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3110 
    args = insureItem_args()
3111 
    args.itemId = itemId
3112 
    args.cartId = cartId
3113 
    args.toInsure = toInsure
9299 kshitij.so 3114 
    args.insurerType = insurerType
6903 anupam.sin 3115 
    args.write(self._oprot)
3116 
    self._oprot.writeMessageEnd()
3117 
    self._oprot.trans.flush()
3118 
 
3119 
  def recv_insureItem(self, ):
3120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3121 
    if mtype == TMessageType.EXCEPTION:
3122 
      x = TApplicationException()
3123 
      x.read(self._iprot)
3124 
      self._iprot.readMessageEnd()
3125 
      raise x
3126 
    result = insureItem_result()
3127 
    result.read(self._iprot)
3128 
    self._iprot.readMessageEnd()
3129 
    if result.success is not None:
3130 
      return result.success
3131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3132 
 
3133 
  def cancelInsurance(self, cartId):
3134 
    """
3135 
    Cancel insurance for all items in the cart
3136 
 
3137 
    Parameters:
3138 
     - cartId
3139 
    """
3140 
    self.send_cancelInsurance(cartId)
3141 
    return self.recv_cancelInsurance()
3142 
 
3143 
  def send_cancelInsurance(self, cartId):
3144 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3145 
    args = cancelInsurance_args()
3146 
    args.cartId = cartId
3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
3151 
  def recv_cancelInsurance(self, ):
3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
3158 
    result = cancelInsurance_result()
3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3161 
    if result.success is not None:
3162 
      return result.success
3163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3164 
 
3165 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3166 
    """
3167 
    Stores insurance specific details like date of birth and guardianName
3168 
 
3169 
    Parameters:
3170 
     - addressId
3171 
     - dob
3172 
     - guardianName
3173 
    """
3174 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3175 
    return self.recv_storeInsuranceSpecificDetails()
3176 
 
3177 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3178 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3179 
    args = storeInsuranceSpecificDetails_args()
3180 
    args.addressId = addressId
3181 
    args.dob = dob
3182 
    args.guardianName = guardianName
3183 
    args.write(self._oprot)
3184 
    self._oprot.writeMessageEnd()
3185 
    self._oprot.trans.flush()
3186 
 
3187 
  def recv_storeInsuranceSpecificDetails(self, ):
3188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3189 
    if mtype == TMessageType.EXCEPTION:
3190 
      x = TApplicationException()
3191 
      x.read(self._iprot)
3192 
      self._iprot.readMessageEnd()
3193 
      raise x
3194 
    result = storeInsuranceSpecificDetails_result()
3195 
    result.read(self._iprot)
3196 
    self._iprot.readMessageEnd()
3197 
    if result.success is not None:
3198 
      return result.success
3199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3200 
 
3201 
  def isInsuranceDetailPresent(self, addressId):
3202 
    """
3203 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3204 
 
3205 
    Parameters:
3206 
     - addressId
3207 
    """
3208 
    self.send_isInsuranceDetailPresent(addressId)
3209 
    return self.recv_isInsuranceDetailPresent()
3210 
 
3211 
  def send_isInsuranceDetailPresent(self, addressId):
3212 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3213 
    args = isInsuranceDetailPresent_args()
3214 
    args.addressId = addressId
3215 
    args.write(self._oprot)
3216 
    self._oprot.writeMessageEnd()
3217 
    self._oprot.trans.flush()
3218 
 
3219 
  def recv_isInsuranceDetailPresent(self, ):
3220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3221 
    if mtype == TMessageType.EXCEPTION:
3222 
      x = TApplicationException()
3223 
      x.read(self._iprot)
3224 
      self._iprot.readMessageEnd()
3225 
      raise x
3226 
    result = isInsuranceDetailPresent_result()
3227 
    result.read(self._iprot)
3228 
    self._iprot.readMessageEnd()
3229 
    if result.success is not None:
3230 
      return result.success
3231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3232 
 
9791 rajveer 3233 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3234 
    """
9791 rajveer 3235 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3236 
 
6821 amar.kumar 3237 
    Parameters:
3238 
     - startDate
3239 
     - endDate
3240 
    """
9791 rajveer 3241 
    self.send_getProductsAddedToCart(startDate, endDate)
3242 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3243 
 
9791 rajveer 3244 
  def send_getProductsAddedToCart(self, startDate, endDate):
3245 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3246 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3247 
    args.startDate = startDate
3248 
    args.endDate = endDate
3249 
    args.write(self._oprot)
3250 
    self._oprot.writeMessageEnd()
3251 
    self._oprot.trans.flush()
3252 
 
9791 rajveer 3253 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3255 
    if mtype == TMessageType.EXCEPTION:
3256 
      x = TApplicationException()
3257 
      x.read(self._iprot)
3258 
      self._iprot.readMessageEnd()
3259 
      raise x
9791 rajveer 3260 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3261 
    result.read(self._iprot)
3262 
    self._iprot.readMessageEnd()
3263 
    if result.success is not None:
3264 
      return result.success
9791 rajveer 3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3266 
 
11980 amit.gupta 3267 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3268 
    """
3269 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3270 
 
11592 amit.gupta 3271 
    Parameters:
3272 
     - cartId
3273 
     - sourceId
11980 amit.gupta 3274 
     - dealerCoupon
11592 amit.gupta 3275 
    """
11980 amit.gupta 3276 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3277 
    return self.recv_validateCartPlus()
3278 
 
11980 amit.gupta 3279 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3280 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3281 
    args = validateCartPlus_args()
3282 
    args.cartId = cartId
3283 
    args.sourceId = sourceId
11980 amit.gupta 3284 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3285 
    args.write(self._oprot)
3286 
    self._oprot.writeMessageEnd()
3287 
    self._oprot.trans.flush()
3288 
 
3289 
  def recv_validateCartPlus(self, ):
3290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3291 
    if mtype == TMessageType.EXCEPTION:
3292 
      x = TApplicationException()
3293 
      x.read(self._iprot)
3294 
      self._iprot.readMessageEnd()
3295 
      raise x
3296 
    result = validateCartPlus_result()
3297 
    result.read(self._iprot)
3298 
    self._iprot.readMessageEnd()
3299 
    if result.success is not None:
3300 
      return result.success
3301 
    if result.scex is not None:
3302 
      raise result.scex
3303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3304 
 
11679 vikram.rag 3305 
  def isPrivateDealUser(self, userId):
3306 
    """
3307 
    Parameters:
3308 
     - userId
3309 
    """
3310 
    self.send_isPrivateDealUser(userId)
3311 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3312 
 
11679 vikram.rag 3313 
  def send_isPrivateDealUser(self, userId):
3314 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3315 
    args = isPrivateDealUser_args()
3316 
    args.userId = userId
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_isPrivateDealUser(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = isPrivateDealUser_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
3331 
    if result.success is not None:
3332 
      return result.success
3333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3334 
 
11890 kshitij.so 3335 
  def addPrivateDealUser(self, userId):
3336 
    """
3337 
    Parameters:
3338 
     - userId
3339 
    """
3340 
    self.send_addPrivateDealUser(userId)
3341 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3342 
 
11890 kshitij.so 3343 
  def send_addPrivateDealUser(self, userId):
3344 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3345 
    args = addPrivateDealUser_args()
3346 
    args.userId = userId
3347 
    args.write(self._oprot)
3348 
    self._oprot.writeMessageEnd()
3349 
    self._oprot.trans.flush()
3350 
 
3351 
  def recv_addPrivateDealUser(self, ):
3352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3353 
    if mtype == TMessageType.EXCEPTION:
3354 
      x = TApplicationException()
3355 
      x.read(self._iprot)
3356 
      self._iprot.readMessageEnd()
3357 
      raise x
3358 
    result = addPrivateDealUser_result()
3359 
    result.read(self._iprot)
3360 
    self._iprot.readMessageEnd()
3361 
    if result.success is not None:
3362 
      return result.success
3363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3364 
 
3365 
  def changePrivateDealUserStatus(self, userId, isActive):
3366 
    """
3367 
    Parameters:
3368 
     - userId
3369 
     - isActive
3370 
    """
3371 
    self.send_changePrivateDealUserStatus(userId, isActive)
3372 
    return self.recv_changePrivateDealUserStatus()
3373 
 
3374 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3375 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3376 
    args = changePrivateDealUserStatus_args()
3377 
    args.userId = userId
3378 
    args.isActive = isActive
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_changePrivateDealUserStatus(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = changePrivateDealUserStatus_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3396 
 
3397 
  def getPrivateDealUser(self, userId):
3398 
    """
3399 
    Parameters:
3400 
     - userId
3401 
    """
3402 
    self.send_getPrivateDealUser(userId)
3403 
    return self.recv_getPrivateDealUser()
3404 
 
3405 
  def send_getPrivateDealUser(self, userId):
3406 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3407 
    args = getPrivateDealUser_args()
3408 
    args.userId = userId
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_getPrivateDealUser(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = getPrivateDealUser_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    if result.success is not None:
3424 
      return result.success
3425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3426 
 
12696 amit.gupta 3427 
  def registerCounter(self, counter, userId):
3428 
    """
3429 
    Parameters:
3430 
     - counter
3431 
     - userId
3432 
    """
3433 
    self.send_registerCounter(counter, userId)
3434 
    return self.recv_registerCounter()
11890 kshitij.so 3435 
 
12696 amit.gupta 3436 
  def send_registerCounter(self, counter, userId):
3437 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3438 
    args = registerCounter_args()
3439 
    args.counter = counter
3440 
    args.userId = userId
3441 
    args.write(self._oprot)
3442 
    self._oprot.writeMessageEnd()
3443 
    self._oprot.trans.flush()
3444 
 
3445 
  def recv_registerCounter(self, ):
3446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3447 
    if mtype == TMessageType.EXCEPTION:
3448 
      x = TApplicationException()
3449 
      x.read(self._iprot)
3450 
      self._iprot.readMessageEnd()
3451 
      raise x
3452 
    result = registerCounter_result()
3453 
    result.read(self._iprot)
3454 
    self._iprot.readMessageEnd()
3455 
    if result.success is not None:
3456 
      return result.success
3457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3458 
 
12722 amit.gupta 3459 
  def searchCounter(self, type1, searchString):
3460 
    """
3461 
    Parameters:
3462 
     - type1
3463 
     - searchString
3464 
    """
3465 
    self.send_searchCounter(type1, searchString)
3466 
    return self.recv_searchCounter()
12696 amit.gupta 3467 
 
12722 amit.gupta 3468 
  def send_searchCounter(self, type1, searchString):
3469 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3470 
    args = searchCounter_args()
3471 
    args.type1 = type1
3472 
    args.searchString = searchString
3473 
    args.write(self._oprot)
3474 
    self._oprot.writeMessageEnd()
3475 
    self._oprot.trans.flush()
3476 
 
3477 
  def recv_searchCounter(self, ):
3478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3479 
    if mtype == TMessageType.EXCEPTION:
3480 
      x = TApplicationException()
3481 
      x.read(self._iprot)
3482 
      self._iprot.readMessageEnd()
3483 
      raise x
3484 
    result = searchCounter_result()
3485 
    result.read(self._iprot)
3486 
    self._iprot.readMessageEnd()
3487 
    if result.success is not None:
3488 
      return result.success
3489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3490 
 
18977 amit.gupta 3491 
  def getCounterByUserId(self, userId):
3492 
    """
3493 
    Parameters:
3494 
     - userId
3495 
    """
3496 
    self.send_getCounterByUserId(userId)
3497 
    return self.recv_getCounterByUserId()
3498 
 
3499 
  def send_getCounterByUserId(self, userId):
3500 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3501 
    args = getCounterByUserId_args()
3502 
    args.userId = userId
3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
3507 
  def recv_getCounterByUserId(self, ):
3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
3514 
    result = getCounterByUserId_result()
3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3517 
    if result.success is not None:
3518 
      return result.success
3519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3520 
 
12722 amit.gupta 3521 
  def getAllUsersByCounter(self, counterId):
3522 
    """
3523 
    Parameters:
3524 
     - counterId
3525 
    """
3526 
    self.send_getAllUsersByCounter(counterId)
3527 
    return self.recv_getAllUsersByCounter()
3528 
 
3529 
  def send_getAllUsersByCounter(self, counterId):
3530 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3531 
    args = getAllUsersByCounter_args()
3532 
    args.counterId = counterId
3533 
    args.write(self._oprot)
3534 
    self._oprot.writeMessageEnd()
3535 
    self._oprot.trans.flush()
3536 
 
3537 
  def recv_getAllUsersByCounter(self, ):
3538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3539 
    if mtype == TMessageType.EXCEPTION:
3540 
      x = TApplicationException()
3541 
      x.read(self._iprot)
3542 
      self._iprot.readMessageEnd()
3543 
      raise x
3544 
    result = getAllUsersByCounter_result()
3545 
    result.read(self._iprot)
3546 
    self._iprot.readMessageEnd()
3547 
    if result.success is not None:
3548 
      return result.success
3549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3550 
 
15251 manish.sha 3551 
  def getActiveAccessTokenForUser(self, userId, source):
3552 
    """
3553 
    Parameters:
3554 
     - userId
3555 
     - source
3556 
    """
3557 
    self.send_getActiveAccessTokenForUser(userId, source)
3558 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3559 
 
15251 manish.sha 3560 
  def send_getActiveAccessTokenForUser(self, userId, source):
3561 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3562 
    args = getActiveAccessTokenForUser_args()
3563 
    args.userId = userId
3564 
    args.source = source
3565 
    args.write(self._oprot)
3566 
    self._oprot.writeMessageEnd()
3567 
    self._oprot.trans.flush()
3568 
 
3569 
  def recv_getActiveAccessTokenForUser(self, ):
3570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3571 
    if mtype == TMessageType.EXCEPTION:
3572 
      x = TApplicationException()
3573 
      x.read(self._iprot)
3574 
      self._iprot.readMessageEnd()
3575 
      raise x
3576 
    result = getActiveAccessTokenForUser_result()
3577 
    result.read(self._iprot)
3578 
    self._iprot.readMessageEnd()
3579 
    if result.success is not None:
3580 
      return result.success
3581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3582 
 
3583 
  def validateAccessToken(self, accessToken):
3584 
    """
3585 
    Parameters:
3586 
     - accessToken
3587 
    """
3588 
    self.send_validateAccessToken(accessToken)
3589 
    return self.recv_validateAccessToken()
3590 
 
3591 
  def send_validateAccessToken(self, accessToken):
3592 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3593 
    args = validateAccessToken_args()
3594 
    args.accessToken = accessToken
3595 
    args.write(self._oprot)
3596 
    self._oprot.writeMessageEnd()
3597 
    self._oprot.trans.flush()
3598 
 
3599 
  def recv_validateAccessToken(self, ):
3600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3601 
    if mtype == TMessageType.EXCEPTION:
3602 
      x = TApplicationException()
3603 
      x.read(self._iprot)
3604 
      self._iprot.readMessageEnd()
3605 
      raise x
3606 
    result = validateAccessToken_result()
3607 
    result.read(self._iprot)
3608 
    self._iprot.readMessageEnd()
3609 
    if result.success is not None:
3610 
      return result.success
3611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3612 
 
17782 amit.gupta 3613 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3614 
    """
3615 
    Parameters:
3616 
     - cartId
3617 
     - itemQty
3618 
     - couponCode
3619 
    """
3620 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3621 
    return self.recv_addItemsToCart()
15251 manish.sha 3622 
 
17782 amit.gupta 3623 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3624 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3625 
    args = addItemsToCart_args()
3626 
    args.cartId = cartId
3627 
    args.itemQty = itemQty
3628 
    args.couponCode = couponCode
3629 
    args.write(self._oprot)
3630 
    self._oprot.writeMessageEnd()
3631 
    self._oprot.trans.flush()
3632 
 
3633 
  def recv_addItemsToCart(self, ):
3634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3635 
    if mtype == TMessageType.EXCEPTION:
3636 
      x = TApplicationException()
3637 
      x.read(self._iprot)
3638 
      self._iprot.readMessageEnd()
3639 
      raise x
3640 
    result = addItemsToCart_result()
3641 
    result.read(self._iprot)
3642 
    self._iprot.readMessageEnd()
3643 
    if result.success is not None:
3644 
      return result.success
3645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3646 
 
3647 
  def validateCartNew(self, cartId, pinCode, sourceId):
3648 
    """
3649 
    Parameters:
3650 
     - cartId
3651 
     - pinCode
3652 
     - sourceId
3653 
    """
3654 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3655 
    return self.recv_validateCartNew()
3656 
 
3657 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3658 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3659 
    args = validateCartNew_args()
3660 
    args.cartId = cartId
3661 
    args.pinCode = pinCode
3662 
    args.sourceId = sourceId
3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_validateCartNew(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = validateCartNew_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.success is not None:
3678 
      return result.success
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3680 
 
18644 manish.sha 3681 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3682 
    """
3683 
    Parameters:
3684 
     - userId
3685 
    """
18644 manish.sha 3686 
    self.send_isAddressEditableForCounter(userId)
3687 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3688 
 
18644 manish.sha 3689 
  def send_isAddressEditableForCounter(self, userId):
3690 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3691 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3692 
    args.userId = userId
3693 
    args.write(self._oprot)
3694 
    self._oprot.writeMessageEnd()
3695 
    self._oprot.trans.flush()
3696 
 
18644 manish.sha 3697 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3699 
    if mtype == TMessageType.EXCEPTION:
3700 
      x = TApplicationException()
3701 
      x.read(self._iprot)
3702 
      self._iprot.readMessageEnd()
3703 
      raise x
18644 manish.sha 3704 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3705 
    result.read(self._iprot)
3706 
    self._iprot.readMessageEnd()
3707 
    if result.success is not None:
3708 
      return result.success
18644 manish.sha 3709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3710 
 
3711 
  def getBillingAddressForUser(self, userId):
3712 
    """
3713 
    Parameters:
3714 
     - userId
3715 
    """
3716 
    self.send_getBillingAddressForUser(userId)
3717 
    return self.recv_getBillingAddressForUser()
3718 
 
3719 
  def send_getBillingAddressForUser(self, userId):
3720 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3721 
    args = getBillingAddressForUser_args()
3722 
    args.userId = userId
3723 
    args.write(self._oprot)
3724 
    self._oprot.writeMessageEnd()
3725 
    self._oprot.trans.flush()
3726 
 
3727 
  def recv_getBillingAddressForUser(self, ):
3728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3729 
    if mtype == TMessageType.EXCEPTION:
3730 
      x = TApplicationException()
3731 
      x.read(self._iprot)
3732 
      self._iprot.readMessageEnd()
3733 
      raise x
3734 
    result = getBillingAddressForUser_result()
3735 
    result.read(self._iprot)
3736 
    self._iprot.readMessageEnd()
3737 
    if result.success is not None:
3738 
      return result.success
3739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3740 
 
18590 manish.sha 3741 
  def isCreditorAssigned(self, userId):
3742 
    """
3743 
    Parameters:
3744 
     - userId
3745 
    """
3746 
    self.send_isCreditorAssigned(userId)
3747 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3748 
 
18590 manish.sha 3749 
  def send_isCreditorAssigned(self, userId):
3750 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3751 
    args = isCreditorAssigned_args()
3752 
    args.userId = userId
3753 
    args.write(self._oprot)
3754 
    self._oprot.writeMessageEnd()
3755 
    self._oprot.trans.flush()
3756 
 
3757 
  def recv_isCreditorAssigned(self, ):
3758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3759 
    if mtype == TMessageType.EXCEPTION:
3760 
      x = TApplicationException()
3761 
      x.read(self._iprot)
3762 
      self._iprot.readMessageEnd()
3763 
      raise x
3764 
    result = isCreditorAssigned_result()
3765 
    result.read(self._iprot)
3766 
    self._iprot.readMessageEnd()
3767 
    if result.success is not None:
3768 
      return result.success
3769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3770 
 
18735 manish.sha 3771 
  def isTaxInvoiceEnabledUser(self, userId):
3772 
    """
3773 
    Parameters:
3774 
     - userId
3775 
    """
3776 
    self.send_isTaxInvoiceEnabledUser(userId)
3777 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3778 
 
18735 manish.sha 3779 
  def send_isTaxInvoiceEnabledUser(self, userId):
3780 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3781 
    args = isTaxInvoiceEnabledUser_args()
3782 
    args.userId = userId
3783 
    args.write(self._oprot)
3784 
    self._oprot.writeMessageEnd()
3785 
    self._oprot.trans.flush()
3786 
 
3787 
  def recv_isTaxInvoiceEnabledUser(self, ):
3788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3789 
    if mtype == TMessageType.EXCEPTION:
3790 
      x = TApplicationException()
3791 
      x.read(self._iprot)
3792 
      self._iprot.readMessageEnd()
3793 
      raise x
3794 
    result = isTaxInvoiceEnabledUser_result()
3795 
    result.read(self._iprot)
3796 
    self._iprot.readMessageEnd()
3797 
    if result.success is not None:
3798 
      return result.success
3799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3800 
 
19182 amit.gupta 3801 
  def taxInvoiceAvailable(self, addressId):
3802 
    """
3803 
    Parameters:
3804 
     - addressId
3805 
    """
3806 
    self.send_taxInvoiceAvailable(addressId)
3807 
    return self.recv_taxInvoiceAvailable()
3808 
 
3809 
  def send_taxInvoiceAvailable(self, addressId):
3810 
    self._oprot.writeMessageBegin('taxInvoiceAvailable', TMessageType.CALL, self._seqid)
3811 
    args = taxInvoiceAvailable_args()
3812 
    args.addressId = addressId
3813 
    args.write(self._oprot)
3814 
    self._oprot.writeMessageEnd()
3815 
    self._oprot.trans.flush()
3816 
 
3817 
  def recv_taxInvoiceAvailable(self, ):
3818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3819 
    if mtype == TMessageType.EXCEPTION:
3820 
      x = TApplicationException()
3821 
      x.read(self._iprot)
3822 
      self._iprot.readMessageEnd()
3823 
      raise x
3824 
    result = taxInvoiceAvailable_result()
3825 
    result.read(self._iprot)
3826 
    self._iprot.readMessageEnd()
3827 
    if result.success is not None:
3828 
      return result.success
3829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "taxInvoiceAvailable failed: unknown result");
3830 
 
18764 kshitij.so 3831 
  def getCartByValue(self, cartIds):
3832 
    """
3833 
    Parameters:
3834 
     - cartIds
3835 
    """
3836 
    self.send_getCartByValue(cartIds)
3837 
    return self.recv_getCartByValue()
18735 manish.sha 3838 
 
18764 kshitij.so 3839 
  def send_getCartByValue(self, cartIds):
3840 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3841 
    args = getCartByValue_args()
3842 
    args.cartIds = cartIds
3843 
    args.write(self._oprot)
3844 
    self._oprot.writeMessageEnd()
3845 
    self._oprot.trans.flush()
3846 
 
3847 
  def recv_getCartByValue(self, ):
3848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3849 
    if mtype == TMessageType.EXCEPTION:
3850 
      x = TApplicationException()
3851 
      x.read(self._iprot)
3852 
      self._iprot.readMessageEnd()
3853 
      raise x
3854 
    result = getCartByValue_result()
3855 
    result.read(self._iprot)
3856 
    self._iprot.readMessageEnd()
3857 
    if result.success is not None:
3858 
      return result.success
3859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3860 
 
3861 
 
3376 rajveer 3862 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3863 
  def __init__(self, handler):
3376 rajveer 3864 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3865 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3866 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3867 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3868 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3869 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3870 
    self._processMap["createUser"] = Processor.process_createUser
3871 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3872 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3873 
    self._processMap["userExists"] = Processor.process_userExists
3874 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3875 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3876 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3877 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3878 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3879 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3880 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3881 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3882 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3883 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3884 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3885 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3886 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3887 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3888 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3889 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3890 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3891 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3892 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3893 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3894 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3895 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3896 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3897 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3898 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3899 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3900 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3901 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3902 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3903 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3904 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3905 
    self._processMap["getCart"] = Processor.process_getCart
3906 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3907 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3908 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3909 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3910 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3911 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3912 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3913 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3914 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3915 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3916 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3917 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3918 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3919 
    self._processMap["checkOut"] = Processor.process_checkOut
3920 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3921 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3922 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3923 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3924 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3925 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3926 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3927 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3928 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3929 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3930 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3931 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3932 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3933 
    self._processMap["insureItem"] = Processor.process_insureItem
3934 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3935 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3936 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3937 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3938 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3939 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3940 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3941 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3942 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3943 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3944 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 3945 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 3946 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3947 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3948 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3949 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3950 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3951 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3952 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3953 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 3954 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
19182 amit.gupta 3955 
    self._processMap["taxInvoiceAvailable"] = Processor.process_taxInvoiceAvailable
18764 kshitij.so 3956 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
94 ashish 3957 
 
3958 
  def process(self, iprot, oprot):
3959 
    (name, type, seqid) = iprot.readMessageBegin()
3960 
    if name not in self._processMap:
3961 
      iprot.skip(TType.STRUCT)
3962 
      iprot.readMessageEnd()
3963 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3964 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3965 
      x.write(oprot)
3966 
      oprot.writeMessageEnd()
3967 
      oprot.trans.flush()
3968 
      return
3969 
    else:
3970 
      self._processMap[name](self, seqid, iprot, oprot)
3971 
    return True
3972 
 
559 chandransh 3973 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3974 
    args = createAnonymousUser_args()
94 ashish 3975 
    args.read(iprot)
3976 
    iprot.readMessageEnd()
559 chandransh 3977 
    result = createAnonymousUser_result()
94 ashish 3978 
    try:
559 chandransh 3979 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3980 
    except UserContextException, ucex:
3981 
      result.ucex = ucex
3982 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3983 
    result.write(oprot)
3984 
    oprot.writeMessageEnd()
3985 
    oprot.trans.flush()
3986 
 
559 chandransh 3987 
  def process_getUserById(self, seqid, iprot, oprot):
3988 
    args = getUserById_args()
94 ashish 3989 
    args.read(iprot)
3990 
    iprot.readMessageEnd()
559 chandransh 3991 
    result = getUserById_result()
94 ashish 3992 
    try:
559 chandransh 3993 
      result.success = self._handler.getUserById(args.userId)
3994 
    except UserContextException, ucex:
3995 
      result.ucex = ucex
3996 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3997 
    result.write(oprot)
3998 
    oprot.writeMessageEnd()
3999 
    oprot.trans.flush()
4000 
 
5326 rajveer 4001 
  def process_getUserByCartId(self, seqid, iprot, oprot):
4002 
    args = getUserByCartId_args()
4003 
    args.read(iprot)
4004 
    iprot.readMessageEnd()
4005 
    result = getUserByCartId_result()
4006 
    try:
4007 
      result.success = self._handler.getUserByCartId(args.cartId)
4008 
    except UserContextException, ucex:
4009 
      result.ucex = ucex
4010 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
4011 
    result.write(oprot)
4012 
    oprot.writeMessageEnd()
4013 
    oprot.trans.flush()
4014 
 
1491 vikas 4015 
  def process_getUserByEmail(self, seqid, iprot, oprot):
4016 
    args = getUserByEmail_args()
4017 
    args.read(iprot)
4018 
    iprot.readMessageEnd()
4019 
    result = getUserByEmail_result()
4020 
    try:
4021 
      result.success = self._handler.getUserByEmail(args.email)
4022 
    except UserContextException, ucex:
4023 
      result.ucex = ucex
4024 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
4025 
    result.write(oprot)
4026 
    oprot.writeMessageEnd()
4027 
    oprot.trans.flush()
4028 
 
3032 mandeep.dh 4029 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
4030 
    args = getUserByMobileNumber_args()
4031 
    args.read(iprot)
4032 
    iprot.readMessageEnd()
4033 
    result = getUserByMobileNumber_result()
4034 
    try:
4035 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
4036 
    except UserContextException, ucex:
4037 
      result.ucex = ucex
4038 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4039 
    result.write(oprot)
4040 
    oprot.writeMessageEnd()
4041 
    oprot.trans.flush()
4042 
 
559 chandransh 4043 
  def process_createUser(self, seqid, iprot, oprot):
4044 
    args = createUser_args()
94 ashish 4045 
    args.read(iprot)
4046 
    iprot.readMessageEnd()
559 chandransh 4047 
    result = createUser_result()
94 ashish 4048 
    try:
559 chandransh 4049 
      result.success = self._handler.createUser(args.user)
4050 
    except UserContextException, ucex:
4051 
      result.ucex = ucex
4052 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4053 
    result.write(oprot)
4054 
    oprot.writeMessageEnd()
4055 
    oprot.trans.flush()
4056 
 
559 chandransh 4057 
  def process_updateUser(self, seqid, iprot, oprot):
4058 
    args = updateUser_args()
94 ashish 4059 
    args.read(iprot)
4060 
    iprot.readMessageEnd()
559 chandransh 4061 
    result = updateUser_result()
94 ashish 4062 
    try:
559 chandransh 4063 
      result.success = self._handler.updateUser(args.user)
4064 
    except UserContextException, ucex:
4065 
      result.ucex = ucex
4066 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4067 
    result.write(oprot)
4068 
    oprot.writeMessageEnd()
4069 
    oprot.trans.flush()
4070 
 
122 ashish 4071 
  def process_authenticateUser(self, seqid, iprot, oprot):
4072 
    args = authenticateUser_args()
4073 
    args.read(iprot)
4074 
    iprot.readMessageEnd()
4075 
    result = authenticateUser_result()
4076 
    try:
559 chandransh 4077 
      result.success = self._handler.authenticateUser(args.email, args.password)
4078 
    except AuthenticationException, auex:
4079 
      result.auex = auex
122 ashish 4080 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4081 
    result.write(oprot)
4082 
    oprot.writeMessageEnd()
4083 
    oprot.trans.flush()
4084 
 
94 ashish 4085 
  def process_userExists(self, seqid, iprot, oprot):
4086 
    args = userExists_args()
4087 
    args.read(iprot)
4088 
    iprot.readMessageEnd()
4089 
    result = userExists_result()
4090 
    try:
4091 
      result.success = self._handler.userExists(args.email)
4092 
    except UserContextException, ucx:
4093 
      result.ucx = ucx
4094 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4095 
    result.write(oprot)
4096 
    oprot.writeMessageEnd()
4097 
    oprot.trans.flush()
4098 
 
4099 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4100 
    args = addAddressForUser_args()
4101 
    args.read(iprot)
4102 
    iprot.readMessageEnd()
4103 
    result = addAddressForUser_result()
4104 
    try:
567 rajveer 4105 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4106 
    except UserContextException, ucx:
4107 
      result.ucx = ucx
4108 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4109 
    result.write(oprot)
4110 
    oprot.writeMessageEnd()
4111 
    oprot.trans.flush()
4112 
 
4113 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4114 
    args = removeAddressForUser_args()
4115 
    args.read(iprot)
4116 
    iprot.readMessageEnd()
4117 
    result = removeAddressForUser_result()
4118 
    try:
4119 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4120 
    except UserContextException, ucx:
4121 
      result.ucx = ucx
4122 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4127 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4128 
    args = setUserAsLoggedIn_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = setUserAsLoggedIn_result()
4132 
    try:
4133 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4134 
    except UserContextException, ucx:
4135 
      result.ucx = ucx
4136 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4137 
    result.write(oprot)
4138 
    oprot.writeMessageEnd()
4139 
    oprot.trans.flush()
4140 
 
4141 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4142 
    args = setUserAsLoggedOut_args()
4143 
    args.read(iprot)
4144 
    iprot.readMessageEnd()
4145 
    result = setUserAsLoggedOut_result()
4146 
    try:
4147 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4148 
    except UserContextException, ucx:
4149 
      result.ucx = ucx
4150 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
504 rajveer 4155 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4156 
    args = setDefaultAddress_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = setDefaultAddress_result()
4160 
    try:
4161 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4162 
    except UserContextException, ucx:
4163 
      result.ucx = ucx
4164 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
94 ashish 4169 
  def process_updatePassword(self, seqid, iprot, oprot):
4170 
    args = updatePassword_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = updatePassword_result()
4174 
    try:
594 rajveer 4175 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4176 
    except UserContextException, ucx:
4177 
      result.ucx = ucx
4178 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
581 rajveer 4183 
  def process_forgotPassword(self, seqid, iprot, oprot):
4184 
    args = forgotPassword_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = forgotPassword_result()
4188 
    try:
884 rajveer 4189 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4190 
    except UserContextException, ucx:
4191 
      result.ucx = ucx
4192 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
594 rajveer 4197 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4198 
    args = getAllAddressesForUser_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = getAllAddressesForUser_result()
4202 
    try:
4203 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4204 
    except UserContextException, ucx:
4205 
      result.ucx = ucx
4206 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
1894 vikas 4211 
  def process_getAddressById(self, seqid, iprot, oprot):
4212 
    args = getAddressById_args()
4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
4215 
    result = getAddressById_result()
4216 
    try:
4217 
      result.success = self._handler.getAddressById(args.addressId)
4218 
    except UserContextException, ucx:
4219 
      result.ucx = ucx
4220 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4224 
 
594 rajveer 4225 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4226 
    args = getDefaultAddressId_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = getDefaultAddressId_result()
4230 
    try:
4231 
      result.success = self._handler.getDefaultAddressId(args.userId)
4232 
    except UserContextException, ucx:
4233 
      result.ucx = ucx
4234 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
785 rajveer 4239 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4240 
    args = getDefaultPincode_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getDefaultPincode_result()
4244 
    try:
4245 
      result.success = self._handler.getDefaultPincode(args.userId)
4246 
    except UserContextException, ucx:
4247 
      result.ucx = ucx
4248 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
1274 varun.gupt 4253 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4254 
    args = saveUserCommunication_args()
4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
4257 
    result = saveUserCommunication_result()
4258 
    try:
4259 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4260 
    except UserCommunicationException, ucx:
4261 
      result.ucx = ucx
4262 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
4266 
 
1590 varun.gupt 4267 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4268 
    args = getUserCommunicationById_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = getUserCommunicationById_result()
4272 
    try:
4273 
      result.success = self._handler.getUserCommunicationById(args.id)
4274 
    except UserCommunicationException, ucx:
4275 
      result.ucx = ucx
4276 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
4281 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4282 
    args = getUserCommunicationByUser_args()
4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
4285 
    result = getUserCommunicationByUser_result()
4286 
    try:
4287 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4288 
    except UserCommunicationException, ucx:
4289 
      result.ucx = ucx
4290 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
4295 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4296 
    args = getAllUserCommunications_args()
4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
4299 
    result = getAllUserCommunications_result()
4300 
    try:
4301 
      result.success = self._handler.getAllUserCommunications()
4302 
    except UserCommunicationException, ucx:
4303 
      result.ucx = ucx
4304 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
4308 
 
5407 amar.kumar 4309 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4310 
    args = removeUserCommunication_args()
4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
4313 
    result = removeUserCommunication_result()
4314 
    try:
4315 
      self._handler.removeUserCommunication(args.id)
4316 
    except UserCommunicationException, ucx:
4317 
      result.ucx = ucx
4318 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4319 
    result.write(oprot)
4320 
    oprot.writeMessageEnd()
4321 
    oprot.trans.flush()
4322 
 
1845 vikas 4323 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4324 
    args = createMasterAffiliate_args()
4325 
    args.read(iprot)
4326 
    iprot.readMessageEnd()
4327 
    result = createMasterAffiliate_result()
4328 
    try:
1859 vikas 4329 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4330 
    except UserAffiliateException, utx:
1845 vikas 4331 
      result.utx = utx
4332 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4333 
    result.write(oprot)
4334 
    oprot.writeMessageEnd()
4335 
    oprot.trans.flush()
4336 
 
1899 vikas 4337 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4338 
    args = getAllMasterAffiliates_args()
4339 
    args.read(iprot)
4340 
    iprot.readMessageEnd()
4341 
    result = getAllMasterAffiliates_result()
4342 
    try:
4343 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4344 
    except UserAffiliateException, utx:
1899 vikas 4345 
      result.utx = utx
4346 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4347 
    result.write(oprot)
4348 
    oprot.writeMessageEnd()
4349 
    oprot.trans.flush()
4350 
 
1845 vikas 4351 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4352 
    args = getMasterAffiliateById_args()
4353 
    args.read(iprot)
4354 
    iprot.readMessageEnd()
4355 
    result = getMasterAffiliateById_result()
4356 
    try:
4357 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4358 
    except UserAffiliateException, utx:
1845 vikas 4359 
      result.utx = utx
4360 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4361 
    result.write(oprot)
4362 
    oprot.writeMessageEnd()
4363 
    oprot.trans.flush()
4364 
 
4365 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4366 
    args = getMasterAffiliateByName_args()
4367 
    args.read(iprot)
4368 
    iprot.readMessageEnd()
4369 
    result = getMasterAffiliateByName_result()
4370 
    try:
4371 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4372 
    except UserAffiliateException, utx:
1845 vikas 4373 
      result.utx = utx
4374 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4375 
    result.write(oprot)
4376 
    oprot.writeMessageEnd()
4377 
    oprot.trans.flush()
4378 
 
4379 
  def process_createAffiliate(self, seqid, iprot, oprot):
4380 
    args = createAffiliate_args()
4381 
    args.read(iprot)
4382 
    iprot.readMessageEnd()
4383 
    result = createAffiliate_result()
4384 
    try:
1859 vikas 4385 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4386 
    except UserAffiliateException, utx:
1845 vikas 4387 
      result.utx = utx
4388 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4389 
    result.write(oprot)
4390 
    oprot.writeMessageEnd()
4391 
    oprot.trans.flush()
4392 
 
4393 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4394 
    args = getAffiliateById_args()
4395 
    args.read(iprot)
4396 
    iprot.readMessageEnd()
4397 
    result = getAffiliateById_result()
4398 
    try:
4399 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4400 
    except UserAffiliateException, utx:
1845 vikas 4401 
      result.utx = utx
4402 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
4407 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4408 
    args = getAffiliateByName_args()
4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
4411 
    result = getAffiliateByName_result()
4412 
    try:
4413 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4414 
    except UserAffiliateException, utx:
1845 vikas 4415 
      result.utx = utx
4416 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
4420 
 
4421 
  def process_getTrackerById(self, seqid, iprot, oprot):
4422 
    args = getTrackerById_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    result = getTrackerById_result()
4426 
    try:
1996 vikas 4427 
      result.success = self._handler.getTrackerById(args.id)
4428 
    except UserAffiliateException, utx:
1845 vikas 4429 
      result.utx = utx
4430 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
1996 vikas 4435 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4436 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
1996 vikas 4439 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4440 
    try:
1996 vikas 4441 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4442 
    except UserAffiliateException, utx:
1845 vikas 4443 
      result.utx = utx
1996 vikas 4444 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
4448 
 
4449 
  def process_addTrackLog(self, seqid, iprot, oprot):
4450 
    args = addTrackLog_args()
4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
4453 
    result = addTrackLog_result()
4454 
    try:
1996 vikas 4455 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4456 
    except UserAffiliateException, utx:
1845 vikas 4457 
      result.utx = utx
4458 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
4463 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4464 
    args = getTrackLogById_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = getTrackLogById_result()
4468 
    try:
4469 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4470 
    except UserAffiliateException, utx:
1845 vikas 4471 
      result.utx = utx
4472 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
1996 vikas 4477 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4478 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
1996 vikas 4481 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4482 
    try:
3293 vikas 4483 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4484 
    except UserAffiliateException, utx:
1845 vikas 4485 
      result.utx = utx
1996 vikas 4486 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4487 
    result.write(oprot)
4488 
    oprot.writeMessageEnd()
4489 
    oprot.trans.flush()
4490 
 
4491 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4492 
    args = getTrackLogsByUser_args()
4493 
    args.read(iprot)
4494 
    iprot.readMessageEnd()
4495 
    result = getTrackLogsByUser_result()
4496 
    try:
4497 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4498 
    except UserAffiliateException, utx:
1845 vikas 4499 
      result.utx = utx
4500 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
4505 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4506 
    args = getTrackLogs_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = getTrackLogs_result()
4510 
    try:
1996 vikas 4511 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4512 
    except UserAffiliateException, utx:
1845 vikas 4513 
      result.utx = utx
4514 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4515 
    result.write(oprot)
4516 
    oprot.writeMessageEnd()
4517 
    oprot.trans.flush()
4518 
 
559 chandransh 4519 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4520 
    args = getCurrentCart_args()
94 ashish 4521 
    args.read(iprot)
4522 
    iprot.readMessageEnd()
559 chandransh 4523 
    result = getCurrentCart_result()
94 ashish 4524 
    try:
559 chandransh 4525 
      result.success = self._handler.getCurrentCart(args.userId)
4526 
    except ShoppingCartException, scx:
4527 
      result.scx = scx
4528 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4529 
    result.write(oprot)
4530 
    oprot.writeMessageEnd()
4531 
    oprot.trans.flush()
4532 
 
559 chandransh 4533 
  def process_getCart(self, seqid, iprot, oprot):
4534 
    args = getCart_args()
94 ashish 4535 
    args.read(iprot)
4536 
    iprot.readMessageEnd()
559 chandransh 4537 
    result = getCart_result()
94 ashish 4538 
    try:
559 chandransh 4539 
      result.success = self._handler.getCart(args.cartId)
4540 
    except ShoppingCartException, scx:
4541 
      result.scx = scx
4542 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4543 
    result.write(oprot)
4544 
    oprot.writeMessageEnd()
4545 
    oprot.trans.flush()
4546 
 
559 chandransh 4547 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4548 
    args = getCartsByTime_args()
94 ashish 4549 
    args.read(iprot)
4550 
    iprot.readMessageEnd()
559 chandransh 4551 
    result = getCartsByTime_result()
94 ashish 4552 
    try:
559 chandransh 4553 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4554 
    except ShoppingCartException, scx:
4555 
      result.scx = scx
4556 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4557 
    result.write(oprot)
4558 
    oprot.writeMessageEnd()
4559 
    oprot.trans.flush()
4560 
 
559 chandransh 4561 
  def process_addItemToCart(self, seqid, iprot, oprot):
4562 
    args = addItemToCart_args()
130 ashish 4563 
    args.read(iprot)
4564 
    iprot.readMessageEnd()
559 chandransh 4565 
    result = addItemToCart_result()
130 ashish 4566 
    try:
3557 rajveer 4567 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4568 
    except ShoppingCartException, scx:
4569 
      result.scx = scx
4570 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
559 chandransh 4575 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4576 
    args = deleteItemFromCart_args()
4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
4579 
    result = deleteItemFromCart_result()
4580 
    try:
4581 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4582 
    except ShoppingCartException, scx:
4583 
      result.scx = scx
4584 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4585 
    result.write(oprot)
4586 
    oprot.writeMessageEnd()
4587 
    oprot.trans.flush()
130 ashish 4588 
 
559 chandransh 4589 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4590 
    args = addAddressToCart_args()
4591 
    args.read(iprot)
4592 
    iprot.readMessageEnd()
4593 
    result = addAddressToCart_result()
575 chandransh 4594 
    try:
4595 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4596 
    except ShoppingCartException, scx:
4597 
      result.scx = scx
559 chandransh 4598 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4599 
    result.write(oprot)
4600 
    oprot.writeMessageEnd()
4601 
    oprot.trans.flush()
4602 
 
5553 rajveer 4603 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4604 
    args = addStoreToCart_args()
4605 
    args.read(iprot)
4606 
    iprot.readMessageEnd()
4607 
    result = addStoreToCart_result()
4608 
    try:
4609 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4610 
    except ShoppingCartException, scx:
4611 
      result.scx = scx
4612 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4613 
    result.write(oprot)
4614 
    oprot.writeMessageEnd()
4615 
    oprot.trans.flush()
4616 
 
1976 varun.gupt 4617 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4618 
    args = applyCouponToCart_args()
4619 
    args.read(iprot)
4620 
    iprot.readMessageEnd()
4621 
    result = applyCouponToCart_result()
4622 
    try:
6922 anupam.sin 4623 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4624 
    except ShoppingCartException, scx:
4625 
      result.scx = scx
4626 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4627 
    result.write(oprot)
4628 
    oprot.writeMessageEnd()
4629 
    oprot.trans.flush()
4630 
 
4631 
  def process_removeCoupon(self, seqid, iprot, oprot):
4632 
    args = removeCoupon_args()
4633 
    args.read(iprot)
4634 
    iprot.readMessageEnd()
4635 
    result = removeCoupon_result()
4636 
    try:
4637 
      self._handler.removeCoupon(args.cartId)
4638 
    except ShoppingCartException, scx:
4639 
      result.scx = scx
4640 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4641 
    result.write(oprot)
4642 
    oprot.writeMessageEnd()
4643 
    oprot.trans.flush()
4644 
 
3554 varun.gupt 4645 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4646 
    args = deleteDiscountsFromCart_args()
4647 
    args.read(iprot)
4648 
    iprot.readMessageEnd()
4649 
    result = deleteDiscountsFromCart_result()
4650 
    try:
4651 
      self._handler.deleteDiscountsFromCart(args.cartId)
4652 
    except ShoppingCartException, scx:
4653 
      result.scx = scx
4654 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4655 
    result.write(oprot)
4656 
    oprot.writeMessageEnd()
4657 
    oprot.trans.flush()
4658 
 
4659 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4660 
    args = saveDiscounts_args()
4661 
    args.read(iprot)
4662 
    iprot.readMessageEnd()
4663 
    result = saveDiscounts_result()
4664 
    try:
4665 
      self._handler.saveDiscounts(args.discounts)
4666 
    except ShoppingCartException, scx:
4667 
      result.scx = scx
4668 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4669 
    result.write(oprot)
4670 
    oprot.writeMessageEnd()
4671 
    oprot.trans.flush()
4672 
 
690 chandransh 4673 
  def process_createOrders(self, seqid, iprot, oprot):
4674 
    args = createOrders_args()
559 chandransh 4675 
    args.read(iprot)
4676 
    iprot.readMessageEnd()
690 chandransh 4677 
    result = createOrders_result()
559 chandransh 4678 
    try:
11526 amit.gupta 4679 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4680 
    except ShoppingCartException, scx:
4681 
      result.scx = scx
690 chandransh 4682 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_validateCart(self, seqid, iprot, oprot):
4688 
    args = validateCart_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = validateCart_result()
575 chandransh 4692 
    try:
3557 rajveer 4693 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4694 
    except ShoppingCartException, scex:
4695 
      result.scex = scex
559 chandransh 4696 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
11980 amit.gupta 4701 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4702 
    args = validateCartWithDealerCoupon_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = validateCartWithDealerCoupon_result()
4706 
    try:
4707 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4708 
    except ShoppingCartException, scex:
4709 
      result.scex = scex
4710 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4711 
    result.write(oprot)
4712 
    oprot.writeMessageEnd()
4713 
    oprot.trans.flush()
4714 
 
690 chandransh 4715 
  def process_mergeCart(self, seqid, iprot, oprot):
4716 
    args = mergeCart_args()
575 chandransh 4717 
    args.read(iprot)
4718 
    iprot.readMessageEnd()
690 chandransh 4719 
    result = mergeCart_result()
4720 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4721 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4722 
    result.write(oprot)
4723 
    oprot.writeMessageEnd()
4724 
    oprot.trans.flush()
4725 
 
4726 
  def process_checkOut(self, seqid, iprot, oprot):
4727 
    args = checkOut_args()
4728 
    args.read(iprot)
4729 
    iprot.readMessageEnd()
4730 
    result = checkOut_result()
575 chandransh 4731 
    try:
690 chandransh 4732 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4733 
    except ShoppingCartException, scex:
4734 
      result.scex = scex
690 chandransh 4735 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4736 
    result.write(oprot)
4737 
    oprot.writeMessageEnd()
4738 
    oprot.trans.flush()
4739 
 
690 chandransh 4740 
  def process_resetCart(self, seqid, iprot, oprot):
4741 
    args = resetCart_args()
559 chandransh 4742 
    args.read(iprot)
4743 
    iprot.readMessageEnd()
690 chandransh 4744 
    result = resetCart_result()
4745 
    try:
4746 
      result.success = self._handler.resetCart(args.cartId, args.items)
4747 
    except ShoppingCartException, scex:
4748 
      result.scex = scex
4749 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4750 
    result.write(oprot)
4751 
    oprot.writeMessageEnd()
4752 
    oprot.trans.flush()
4753 
 
2981 rajveer 4754 
  def process_getUserCount(self, seqid, iprot, oprot):
4755 
    args = getUserCount_args()
559 chandransh 4756 
    args.read(iprot)
4757 
    iprot.readMessageEnd()
2981 rajveer 4758 
    result = getUserCount_result()
4759 
    result.success = self._handler.getUserCount(args.userType)
4760 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4761 
    result.write(oprot)
4762 
    oprot.writeMessageEnd()
4763 
    oprot.trans.flush()
4764 
 
2981 rajveer 4765 
  def process_getAllUsers(self, seqid, iprot, oprot):
4766 
    args = getAllUsers_args()
559 chandransh 4767 
    args.read(iprot)
4768 
    iprot.readMessageEnd()
2981 rajveer 4769 
    result = getAllUsers_result()
4770 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4771 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
2981 rajveer 4776 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4777 
    args = getMyResearchItems_args()
559 chandransh 4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
2981 rajveer 4780 
    result = getMyResearchItems_result()
559 chandransh 4781 
    try:
2981 rajveer 4782 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4783 
    except WidgetException, scx:
4784 
      result.scx = scx
2981 rajveer 4785 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
4789 
 
2981 rajveer 4790 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4791 
    args = updateMyResearch_args()
772 rajveer 4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
2981 rajveer 4794 
    result = updateMyResearch_result()
4795 
    try:
4796 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4797 
    except WidgetException, scx:
4798 
      result.scx = scx
4799 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4800 
    result.write(oprot)
4801 
    oprot.writeMessageEnd()
4802 
    oprot.trans.flush()
559 chandransh 4803 
 
2981 rajveer 4804 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4805 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4806 
    args.read(iprot)
4807 
    iprot.readMessageEnd()
2981 rajveer 4808 
    result = deleteItemFromMyResearch_result()
4809 
    try:
4810 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4811 
    except WidgetException, scx:
4812 
      result.scx = scx
4813 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
772 rajveer 4817 
 
2981 rajveer 4818 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4819 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4820 
    args.read(iprot)
4821 
    iprot.readMessageEnd()
2981 rajveer 4822 
    result = getBrowseHistoryItems_result()
4823 
    try:
4824 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4825 
    except WidgetException, scx:
4826 
      result.scx = scx
4827 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
1596 ankur.sing 4831 
 
2981 rajveer 4832 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4833 
    args = updateBrowseHistory_args()
2642 varun.gupt 4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
2981 rajveer 4836 
    result = updateBrowseHistory_result()
4837 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4838 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4839 
    result.write(oprot)
4840 
    oprot.writeMessageEnd()
4841 
    oprot.trans.flush()
1673 ankur.sing 4842 
 
3385 varun.gupt 4843 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4844 
    args = getCartsWithCouponCount_args()
4845 
    args.read(iprot)
4846 
    iprot.readMessageEnd()
4847 
    result = getCartsWithCouponCount_result()
4848 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4849 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4850 
    result.write(oprot)
4851 
    oprot.writeMessageEnd()
4852 
    oprot.trans.flush()
2642 varun.gupt 4853 
 
3499 mandeep.dh 4854 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4855 
    args = increaseTrustLevel_args()
4856 
    args.read(iprot)
4857 
    iprot.readMessageEnd()
4858 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4859 
    return
3385 varun.gupt 4860 
 
5407 amar.kumar 4861 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4862 
    args = getTrustLevel_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = getTrustLevel_result()
4866 
    result.success = self._handler.getTrustLevel(args.userId)
4867 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
4668 varun.gupt 4872 
  def process_showCODOption(self, seqid, iprot, oprot):
4873 
    args = showCODOption_args()
4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
4876 
    result = showCODOption_result()
4877 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4878 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
3499 mandeep.dh 4882 
 
5623 anupam.sin 4883 
  def process_getUserEmails(self, seqid, iprot, oprot):
4884 
    args = getUserEmails_args()
4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
4887 
    result = getUserEmails_result()
4888 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4889 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4668 varun.gupt 4893 
 
6903 anupam.sin 4894 
  def process_insureItem(self, seqid, iprot, oprot):
4895 
    args = insureItem_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = insureItem_result()
9299 kshitij.so 4899 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4900 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
4905 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4906 
    args = cancelInsurance_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = cancelInsurance_result()
4910 
    result.success = self._handler.cancelInsurance(args.cartId)
4911 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4917 
    args = storeInsuranceSpecificDetails_args()
4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
4920 
    result = storeInsuranceSpecificDetails_result()
4921 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4922 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
4927 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4928 
    args = isInsuranceDetailPresent_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = isInsuranceDetailPresent_result()
4932 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4933 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
9791 rajveer 4938 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4939 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
9791 rajveer 4942 
    result = getProductsAddedToCart_result()
4943 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4944 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
5623 anupam.sin 4948 
 
11592 amit.gupta 4949 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4950 
    args = validateCartPlus_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = validateCartPlus_result()
4954 
    try:
11980 amit.gupta 4955 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4956 
    except ShoppingCartException, scex:
4957 
      result.scex = scex
4958 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
6821 amar.kumar 4962 
 
11679 vikram.rag 4963 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4964 
    args = isPrivateDealUser_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = isPrivateDealUser_result()
4968 
    result.success = self._handler.isPrivateDealUser(args.userId)
4969 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4970 
    result.write(oprot)
4971 
    oprot.writeMessageEnd()
4972 
    oprot.trans.flush()
11592 amit.gupta 4973 
 
11890 kshitij.so 4974 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4975 
    args = addPrivateDealUser_args()
4976 
    args.read(iprot)
4977 
    iprot.readMessageEnd()
4978 
    result = addPrivateDealUser_result()
4979 
    result.success = self._handler.addPrivateDealUser(args.userId)
4980 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
11679 vikram.rag 4984 
 
11890 kshitij.so 4985 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4986 
    args = changePrivateDealUserStatus_args()
4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
4989 
    result = changePrivateDealUserStatus_result()
4990 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4991 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
4996 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4997 
    args = getPrivateDealUser_args()
4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
5000 
    result = getPrivateDealUser_result()
5001 
    result.success = self._handler.getPrivateDealUser(args.userId)
5002 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
12696 amit.gupta 5007 
  def process_registerCounter(self, seqid, iprot, oprot):
5008 
    args = registerCounter_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = registerCounter_result()
5012 
    result.success = self._handler.registerCounter(args.counter, args.userId)
5013 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
11890 kshitij.so 5017 
 
12722 amit.gupta 5018 
  def process_searchCounter(self, seqid, iprot, oprot):
5019 
    args = searchCounter_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = searchCounter_result()
5023 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
5024 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
12696 amit.gupta 5028 
 
18977 amit.gupta 5029 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
5030 
    args = getCounterByUserId_args()
5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
5033 
    result = getCounterByUserId_result()
5034 
    result.success = self._handler.getCounterByUserId(args.userId)
5035 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
12722 amit.gupta 5040 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5041 
    args = getAllUsersByCounter_args()
5042 
    args.read(iprot)
5043 
    iprot.readMessageEnd()
5044 
    result = getAllUsersByCounter_result()
5045 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5046 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5047 
    result.write(oprot)
5048 
    oprot.writeMessageEnd()
5049 
    oprot.trans.flush()
5050 
 
15251 manish.sha 5051 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5052 
    args = getActiveAccessTokenForUser_args()
5053 
    args.read(iprot)
5054 
    iprot.readMessageEnd()
5055 
    result = getActiveAccessTokenForUser_result()
5056 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5057 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
12722 amit.gupta 5061 
 
15251 manish.sha 5062 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5063 
    args = validateAccessToken_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = validateAccessToken_result()
5067 
    result.success = self._handler.validateAccessToken(args.accessToken)
5068 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5069 
    result.write(oprot)
5070 
    oprot.writeMessageEnd()
5071 
    oprot.trans.flush()
5072 
 
17782 amit.gupta 5073 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5074 
    args = addItemsToCart_args()
5075 
    args.read(iprot)
5076 
    iprot.readMessageEnd()
5077 
    result = addItemsToCart_result()
5078 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5079 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5080 
    result.write(oprot)
5081 
    oprot.writeMessageEnd()
5082 
    oprot.trans.flush()
15251 manish.sha 5083 
 
17782 amit.gupta 5084 
  def process_validateCartNew(self, seqid, iprot, oprot):
5085 
    args = validateCartNew_args()
5086 
    args.read(iprot)
5087 
    iprot.readMessageEnd()
5088 
    result = validateCartNew_result()
5089 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5090 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5091 
    result.write(oprot)
5092 
    oprot.writeMessageEnd()
5093 
    oprot.trans.flush()
5094 
 
18644 manish.sha 5095 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5096 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5097 
    args.read(iprot)
5098 
    iprot.readMessageEnd()
18644 manish.sha 5099 
    result = isAddressEditableForCounter_result()
5100 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5101 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5102 
    result.write(oprot)
5103 
    oprot.writeMessageEnd()
5104 
    oprot.trans.flush()
17782 amit.gupta 5105 
 
18530 manish.sha 5106 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5107 
    args = getBillingAddressForUser_args()
5108 
    args.read(iprot)
5109 
    iprot.readMessageEnd()
5110 
    result = getBillingAddressForUser_result()
5111 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5112 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5113 
    result.write(oprot)
5114 
    oprot.writeMessageEnd()
5115 
    oprot.trans.flush()
5116 
 
18590 manish.sha 5117 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5118 
    args = isCreditorAssigned_args()
5119 
    args.read(iprot)
5120 
    iprot.readMessageEnd()
5121 
    result = isCreditorAssigned_result()
5122 
    result.success = self._handler.isCreditorAssigned(args.userId)
5123 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5124 
    result.write(oprot)
5125 
    oprot.writeMessageEnd()
5126 
    oprot.trans.flush()
18530 manish.sha 5127 
 
18735 manish.sha 5128 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5129 
    args = isTaxInvoiceEnabledUser_args()
5130 
    args.read(iprot)
5131 
    iprot.readMessageEnd()
5132 
    result = isTaxInvoiceEnabledUser_result()
5133 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5134 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5135 
    result.write(oprot)
5136 
    oprot.writeMessageEnd()
5137 
    oprot.trans.flush()
18590 manish.sha 5138 
 
19182 amit.gupta 5139 
  def process_taxInvoiceAvailable(self, seqid, iprot, oprot):
5140 
    args = taxInvoiceAvailable_args()
5141 
    args.read(iprot)
5142 
    iprot.readMessageEnd()
5143 
    result = taxInvoiceAvailable_result()
5144 
    result.success = self._handler.taxInvoiceAvailable(args.addressId)
5145 
    oprot.writeMessageBegin("taxInvoiceAvailable", TMessageType.REPLY, seqid)
5146 
    result.write(oprot)
5147 
    oprot.writeMessageEnd()
5148 
    oprot.trans.flush()
5149 
 
18764 kshitij.so 5150 
  def process_getCartByValue(self, seqid, iprot, oprot):
5151 
    args = getCartByValue_args()
5152 
    args.read(iprot)
5153 
    iprot.readMessageEnd()
5154 
    result = getCartByValue_result()
5155 
    result.success = self._handler.getCartByValue(args.cartIds)
5156 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5157 
    result.write(oprot)
5158 
    oprot.writeMessageEnd()
5159 
    oprot.trans.flush()
18735 manish.sha 5160 
 
18764 kshitij.so 5161 
 
94 ashish 5162 
# HELPER FUNCTIONS AND STRUCTURES
5163 
 
559 chandransh 5164 
class createAnonymousUser_args:
94 ashish 5165 
  """
5166 
  Attributes:
559 chandransh 5167 
   - jsessionId
94 ashish 5168 
  """
5169 
 
5170 
  thrift_spec = (
5171 
    None, # 0
559 chandransh 5172 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5173 
  )
5174 
 
559 chandransh 5175 
  def __init__(self, jsessionId=None,):
5176 
    self.jsessionId = jsessionId
94 ashish 5177 
 
5178 
  def read(self, iprot):
5179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5181 
      return
5182 
    iprot.readStructBegin()
5183 
    while True:
5184 
      (fname, ftype, fid) = iprot.readFieldBegin()
5185 
      if ftype == TType.STOP:
5186 
        break
5187 
      if fid == 1:
559 chandransh 5188 
        if ftype == TType.STRING:
5189 
          self.jsessionId = iprot.readString();
94 ashish 5190 
        else:
5191 
          iprot.skip(ftype)
5192 
      else:
5193 
        iprot.skip(ftype)
5194 
      iprot.readFieldEnd()
5195 
    iprot.readStructEnd()
5196 
 
5197 
  def write(self, oprot):
5198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5200 
      return
559 chandransh 5201 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5202 
    if self.jsessionId is not None:
559 chandransh 5203 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5204 
      oprot.writeString(self.jsessionId)
94 ashish 5205 
      oprot.writeFieldEnd()
5206 
    oprot.writeFieldStop()
5207 
    oprot.writeStructEnd()
5208 
 
3431 rajveer 5209 
  def validate(self):
5210 
    return
5211 
 
5212 
 
94 ashish 5213 
  def __repr__(self):
5214 
    L = ['%s=%r' % (key, value)
5215 
      for key, value in self.__dict__.iteritems()]
5216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5217 
 
5218 
  def __eq__(self, other):
5219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5220 
 
5221 
  def __ne__(self, other):
5222 
    return not (self == other)
5223 
 
559 chandransh 5224 
class createAnonymousUser_result:
94 ashish 5225 
  """
5226 
  Attributes:
5227 
   - success
559 chandransh 5228 
   - ucex
94 ashish 5229 
  """
5230 
 
5231 
  thrift_spec = (
559 chandransh 5232 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5233 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5234 
  )
5235 
 
559 chandransh 5236 
  def __init__(self, success=None, ucex=None,):
94 ashish 5237 
    self.success = success
559 chandransh 5238 
    self.ucex = ucex
94 ashish 5239 
 
5240 
  def read(self, iprot):
5241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5243 
      return
5244 
    iprot.readStructBegin()
5245 
    while True:
5246 
      (fname, ftype, fid) = iprot.readFieldBegin()
5247 
      if ftype == TType.STOP:
5248 
        break
5249 
      if fid == 0:
5250 
        if ftype == TType.STRUCT:
559 chandransh 5251 
          self.success = User()
94 ashish 5252 
          self.success.read(iprot)
5253 
        else:
5254 
          iprot.skip(ftype)
5255 
      elif fid == 1:
5256 
        if ftype == TType.STRUCT:
559 chandransh 5257 
          self.ucex = UserContextException()
5258 
          self.ucex.read(iprot)
94 ashish 5259 
        else:
5260 
          iprot.skip(ftype)
5261 
      else:
5262 
        iprot.skip(ftype)
5263 
      iprot.readFieldEnd()
5264 
    iprot.readStructEnd()
5265 
 
5266 
  def write(self, oprot):
5267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5269 
      return
559 chandransh 5270 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5271 
    if self.success is not None:
94 ashish 5272 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5273 
      self.success.write(oprot)
5274 
      oprot.writeFieldEnd()
3431 rajveer 5275 
    if self.ucex is not None:
559 chandransh 5276 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5277 
      self.ucex.write(oprot)
94 ashish 5278 
      oprot.writeFieldEnd()
5279 
    oprot.writeFieldStop()
5280 
    oprot.writeStructEnd()
5281 
 
3431 rajveer 5282 
  def validate(self):
5283 
    return
5284 
 
5285 
 
94 ashish 5286 
  def __repr__(self):
5287 
    L = ['%s=%r' % (key, value)
5288 
      for key, value in self.__dict__.iteritems()]
5289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5290 
 
5291 
  def __eq__(self, other):
5292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5293 
 
5294 
  def __ne__(self, other):
5295 
    return not (self == other)
5296 
 
559 chandransh 5297 
class getUserById_args:
94 ashish 5298 
  """
5299 
  Attributes:
5300 
   - userId
5301 
  """
5302 
 
5303 
  thrift_spec = (
5304 
    None, # 0
5305 
    (1, TType.I64, 'userId', None, None, ), # 1
5306 
  )
5307 
 
559 chandransh 5308 
  def __init__(self, userId=None,):
94 ashish 5309 
    self.userId = userId
5310 
 
5311 
  def read(self, iprot):
5312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5314 
      return
5315 
    iprot.readStructBegin()
5316 
    while True:
5317 
      (fname, ftype, fid) = iprot.readFieldBegin()
5318 
      if ftype == TType.STOP:
5319 
        break
5320 
      if fid == 1:
5321 
        if ftype == TType.I64:
5322 
          self.userId = iprot.readI64();
5323 
        else:
5324 
          iprot.skip(ftype)
5325 
      else:
5326 
        iprot.skip(ftype)
5327 
      iprot.readFieldEnd()
5328 
    iprot.readStructEnd()
5329 
 
5330 
  def write(self, oprot):
5331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5333 
      return
559 chandransh 5334 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5335 
    if self.userId is not None:
94 ashish 5336 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5337 
      oprot.writeI64(self.userId)
5338 
      oprot.writeFieldEnd()
5339 
    oprot.writeFieldStop()
5340 
    oprot.writeStructEnd()
5341 
 
3431 rajveer 5342 
  def validate(self):
5343 
    return
5344 
 
5345 
 
94 ashish 5346 
  def __repr__(self):
5347 
    L = ['%s=%r' % (key, value)
5348 
      for key, value in self.__dict__.iteritems()]
5349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5350 
 
5351 
  def __eq__(self, other):
5352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5353 
 
5354 
  def __ne__(self, other):
5355 
    return not (self == other)
5356 
 
559 chandransh 5357 
class getUserById_result:
94 ashish 5358 
  """
5359 
  Attributes:
5360 
   - success
559 chandransh 5361 
   - ucex
94 ashish 5362 
  """
5363 
 
5364 
  thrift_spec = (
559 chandransh 5365 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5366 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5367 
  )
5368 
 
559 chandransh 5369 
  def __init__(self, success=None, ucex=None,):
94 ashish 5370 
    self.success = success
559 chandransh 5371 
    self.ucex = ucex
94 ashish 5372 
 
5373 
  def read(self, iprot):
5374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5376 
      return
5377 
    iprot.readStructBegin()
5378 
    while True:
5379 
      (fname, ftype, fid) = iprot.readFieldBegin()
5380 
      if ftype == TType.STOP:
5381 
        break
5382 
      if fid == 0:
5383 
        if ftype == TType.STRUCT:
559 chandransh 5384 
          self.success = User()
94 ashish 5385 
          self.success.read(iprot)
5386 
        else:
5387 
          iprot.skip(ftype)
5388 
      elif fid == 1:
5389 
        if ftype == TType.STRUCT:
559 chandransh 5390 
          self.ucex = UserContextException()
5391 
          self.ucex.read(iprot)
94 ashish 5392 
        else:
5393 
          iprot.skip(ftype)
5394 
      else:
5395 
        iprot.skip(ftype)
5396 
      iprot.readFieldEnd()
5397 
    iprot.readStructEnd()
5398 
 
5399 
  def write(self, oprot):
5400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5402 
      return
559 chandransh 5403 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5404 
    if self.success is not None:
94 ashish 5405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5406 
      self.success.write(oprot)
5407 
      oprot.writeFieldEnd()
3431 rajveer 5408 
    if self.ucex is not None:
559 chandransh 5409 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5410 
      self.ucex.write(oprot)
94 ashish 5411 
      oprot.writeFieldEnd()
5412 
    oprot.writeFieldStop()
5413 
    oprot.writeStructEnd()
5414 
 
3431 rajveer 5415 
  def validate(self):
5416 
    return
5417 
 
5418 
 
94 ashish 5419 
  def __repr__(self):
5420 
    L = ['%s=%r' % (key, value)
5421 
      for key, value in self.__dict__.iteritems()]
5422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5423 
 
5424 
  def __eq__(self, other):
5425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5426 
 
5427 
  def __ne__(self, other):
5428 
    return not (self == other)
5429 
 
5326 rajveer 5430 
class getUserByCartId_args:
1491 vikas 5431 
  """
5432 
  Attributes:
5326 rajveer 5433 
   - cartId
1491 vikas 5434 
  """
5435 
 
5436 
  thrift_spec = (
5437 
    None, # 0
5326 rajveer 5438 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5439 
  )
5440 
 
5326 rajveer 5441 
  def __init__(self, cartId=None,):
5442 
    self.cartId = cartId
1491 vikas 5443 
 
5444 
  def read(self, iprot):
5445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5447 
      return
5448 
    iprot.readStructBegin()
5449 
    while True:
5450 
      (fname, ftype, fid) = iprot.readFieldBegin()
5451 
      if ftype == TType.STOP:
5452 
        break
5453 
      if fid == 1:
5326 rajveer 5454 
        if ftype == TType.I64:
5455 
          self.cartId = iprot.readI64();
1491 vikas 5456 
        else:
5457 
          iprot.skip(ftype)
5458 
      else:
5459 
        iprot.skip(ftype)
5460 
      iprot.readFieldEnd()
5461 
    iprot.readStructEnd()
5462 
 
5463 
  def write(self, oprot):
5464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5466 
      return
5326 rajveer 5467 
    oprot.writeStructBegin('getUserByCartId_args')
5468 
    if self.cartId is not None:
5469 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5470 
      oprot.writeI64(self.cartId)
1491 vikas 5471 
      oprot.writeFieldEnd()
5472 
    oprot.writeFieldStop()
5473 
    oprot.writeStructEnd()
5474 
 
3431 rajveer 5475 
  def validate(self):
5476 
    return
5477 
 
5478 
 
1491 vikas 5479 
  def __repr__(self):
5480 
    L = ['%s=%r' % (key, value)
5481 
      for key, value in self.__dict__.iteritems()]
5482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5483 
 
5484 
  def __eq__(self, other):
5485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5486 
 
5487 
  def __ne__(self, other):
5488 
    return not (self == other)
5489 
 
5326 rajveer 5490 
class getUserByCartId_result:
1491 vikas 5491 
  """
5492 
  Attributes:
5493 
   - success
5494 
   - ucex
5495 
  """
5496 
 
5497 
  thrift_spec = (
5498 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5499 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5500 
  )
5501 
 
5502 
  def __init__(self, success=None, ucex=None,):
5503 
    self.success = success
5504 
    self.ucex = ucex
5505 
 
5506 
  def read(self, iprot):
5507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5509 
      return
5510 
    iprot.readStructBegin()
5511 
    while True:
5512 
      (fname, ftype, fid) = iprot.readFieldBegin()
5513 
      if ftype == TType.STOP:
5514 
        break
5515 
      if fid == 0:
5516 
        if ftype == TType.STRUCT:
5517 
          self.success = User()
5518 
          self.success.read(iprot)
5519 
        else:
5520 
          iprot.skip(ftype)
5521 
      elif fid == 1:
5522 
        if ftype == TType.STRUCT:
5523 
          self.ucex = UserContextException()
5524 
          self.ucex.read(iprot)
5525 
        else:
5526 
          iprot.skip(ftype)
5527 
      else:
5528 
        iprot.skip(ftype)
5529 
      iprot.readFieldEnd()
5530 
    iprot.readStructEnd()
5531 
 
5532 
  def write(self, oprot):
5533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5535 
      return
5326 rajveer 5536 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5537 
    if self.success is not None:
1491 vikas 5538 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5539 
      self.success.write(oprot)
5540 
      oprot.writeFieldEnd()
3431 rajveer 5541 
    if self.ucex is not None:
1491 vikas 5542 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5543 
      self.ucex.write(oprot)
5544 
      oprot.writeFieldEnd()
5545 
    oprot.writeFieldStop()
5546 
    oprot.writeStructEnd()
5547 
 
3431 rajveer 5548 
  def validate(self):
5549 
    return
5550 
 
5551 
 
1491 vikas 5552 
  def __repr__(self):
5553 
    L = ['%s=%r' % (key, value)
5554 
      for key, value in self.__dict__.iteritems()]
5555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5556 
 
5557 
  def __eq__(self, other):
5558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5559 
 
5560 
  def __ne__(self, other):
5561 
    return not (self == other)
5562 
 
5326 rajveer 5563 
class getUserByEmail_args:
3032 mandeep.dh 5564 
  """
5565 
  Attributes:
5326 rajveer 5566 
   - email
3032 mandeep.dh 5567 
  """
5568 
 
5569 
  thrift_spec = (
5570 
    None, # 0
5326 rajveer 5571 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5572 
  )
5573 
 
5326 rajveer 5574 
  def __init__(self, email=None,):
5575 
    self.email = email
3032 mandeep.dh 5576 
 
5577 
  def read(self, iprot):
5578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5580 
      return
5581 
    iprot.readStructBegin()
5582 
    while True:
5583 
      (fname, ftype, fid) = iprot.readFieldBegin()
5584 
      if ftype == TType.STOP:
5585 
        break
5586 
      if fid == 1:
5326 rajveer 5587 
        if ftype == TType.STRING:
5588 
          self.email = iprot.readString();
3032 mandeep.dh 5589 
        else:
5590 
          iprot.skip(ftype)
5591 
      else:
5592 
        iprot.skip(ftype)
5593 
      iprot.readFieldEnd()
5594 
    iprot.readStructEnd()
5595 
 
5596 
  def write(self, oprot):
5597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5599 
      return
5326 rajveer 5600 
    oprot.writeStructBegin('getUserByEmail_args')
5601 
    if self.email is not None:
5602 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5603 
      oprot.writeString(self.email)
3032 mandeep.dh 5604 
      oprot.writeFieldEnd()
5605 
    oprot.writeFieldStop()
5606 
    oprot.writeStructEnd()
5607 
 
3431 rajveer 5608 
  def validate(self):
5609 
    return
5610 
 
5611 
 
3032 mandeep.dh 5612 
  def __repr__(self):
5613 
    L = ['%s=%r' % (key, value)
5614 
      for key, value in self.__dict__.iteritems()]
5615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5616 
 
5617 
  def __eq__(self, other):
5618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5619 
 
5620 
  def __ne__(self, other):
5621 
    return not (self == other)
5622 
 
5326 rajveer 5623 
class getUserByEmail_result:
3032 mandeep.dh 5624 
  """
5625 
  Attributes:
5626 
   - success
5627 
   - ucex
5628 
  """
5629 
 
5630 
  thrift_spec = (
5631 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5632 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5633 
  )
5634 
 
5635 
  def __init__(self, success=None, ucex=None,):
5636 
    self.success = success
5637 
    self.ucex = ucex
5638 
 
5639 
  def read(self, iprot):
5640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5642 
      return
5643 
    iprot.readStructBegin()
5644 
    while True:
5645 
      (fname, ftype, fid) = iprot.readFieldBegin()
5646 
      if ftype == TType.STOP:
5647 
        break
5648 
      if fid == 0:
5649 
        if ftype == TType.STRUCT:
5650 
          self.success = User()
5651 
          self.success.read(iprot)
5652 
        else:
5653 
          iprot.skip(ftype)
5654 
      elif fid == 1:
5655 
        if ftype == TType.STRUCT:
5656 
          self.ucex = UserContextException()
5657 
          self.ucex.read(iprot)
5658 
        else:
5659 
          iprot.skip(ftype)
5660 
      else:
5661 
        iprot.skip(ftype)
5662 
      iprot.readFieldEnd()
5663 
    iprot.readStructEnd()
5664 
 
5665 
  def write(self, oprot):
5666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5668 
      return
5326 rajveer 5669 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5670 
    if self.success is not None:
3032 mandeep.dh 5671 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5672 
      self.success.write(oprot)
5673 
      oprot.writeFieldEnd()
3431 rajveer 5674 
    if self.ucex is not None:
3032 mandeep.dh 5675 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5676 
      self.ucex.write(oprot)
5677 
      oprot.writeFieldEnd()
5678 
    oprot.writeFieldStop()
5679 
    oprot.writeStructEnd()
5680 
 
3431 rajveer 5681 
  def validate(self):
5682 
    return
5683 
 
5684 
 
3032 mandeep.dh 5685 
  def __repr__(self):
5686 
    L = ['%s=%r' % (key, value)
5687 
      for key, value in self.__dict__.iteritems()]
5688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5689 
 
5690 
  def __eq__(self, other):
5691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5692 
 
5693 
  def __ne__(self, other):
5694 
    return not (self == other)
5695 
 
5326 rajveer 5696 
class getUserByMobileNumber_args:
94 ashish 5697 
  """
5698 
  Attributes:
5326 rajveer 5699 
   - mobileNumber
94 ashish 5700 
  """
5701 
 
5702 
  thrift_spec = (
5703 
    None, # 0
5326 rajveer 5704 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5705 
  )
5706 
 
5326 rajveer 5707 
  def __init__(self, mobileNumber=None,):
5708 
    self.mobileNumber = mobileNumber
94 ashish 5709 
 
5710 
  def read(self, iprot):
5711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5713 
      return
5714 
    iprot.readStructBegin()
5715 
    while True:
5716 
      (fname, ftype, fid) = iprot.readFieldBegin()
5717 
      if ftype == TType.STOP:
5718 
        break
5719 
      if fid == 1:
5326 rajveer 5720 
        if ftype == TType.I64:
5721 
          self.mobileNumber = iprot.readI64();
94 ashish 5722 
        else:
5723 
          iprot.skip(ftype)
5724 
      else:
5725 
        iprot.skip(ftype)
5726 
      iprot.readFieldEnd()
5727 
    iprot.readStructEnd()
5728 
 
5729 
  def write(self, oprot):
5730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5732 
      return
5326 rajveer 5733 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5734 
    if self.mobileNumber is not None:
5735 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5736 
      oprot.writeI64(self.mobileNumber)
94 ashish 5737 
      oprot.writeFieldEnd()
5738 
    oprot.writeFieldStop()
5739 
    oprot.writeStructEnd()
5740 
 
3431 rajveer 5741 
  def validate(self):
5742 
    return
5743 
 
5744 
 
94 ashish 5745 
  def __repr__(self):
5746 
    L = ['%s=%r' % (key, value)
5747 
      for key, value in self.__dict__.iteritems()]
5748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5749 
 
5750 
  def __eq__(self, other):
5751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5752 
 
5753 
  def __ne__(self, other):
5754 
    return not (self == other)
5755 
 
5326 rajveer 5756 
class getUserByMobileNumber_result:
94 ashish 5757 
  """
5758 
  Attributes:
5759 
   - success
559 chandransh 5760 
   - ucex
94 ashish 5761 
  """
5762 
 
5763 
  thrift_spec = (
559 chandransh 5764 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5765 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5766 
  )
5767 
 
559 chandransh 5768 
  def __init__(self, success=None, ucex=None,):
94 ashish 5769 
    self.success = success
559 chandransh 5770 
    self.ucex = ucex
94 ashish 5771 
 
5772 
  def read(self, iprot):
5773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5775 
      return
5776 
    iprot.readStructBegin()
5777 
    while True:
5778 
      (fname, ftype, fid) = iprot.readFieldBegin()
5779 
      if ftype == TType.STOP:
5780 
        break
5781 
      if fid == 0:
5782 
        if ftype == TType.STRUCT:
559 chandransh 5783 
          self.success = User()
94 ashish 5784 
          self.success.read(iprot)
5785 
        else:
5786 
          iprot.skip(ftype)
5787 
      elif fid == 1:
5788 
        if ftype == TType.STRUCT:
559 chandransh 5789 
          self.ucex = UserContextException()
5790 
          self.ucex.read(iprot)
94 ashish 5791 
        else:
5792 
          iprot.skip(ftype)
5793 
      else:
5794 
        iprot.skip(ftype)
5795 
      iprot.readFieldEnd()
5796 
    iprot.readStructEnd()
5797 
 
5798 
  def write(self, oprot):
5799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5801 
      return
5326 rajveer 5802 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5803 
    if self.success is not None:
94 ashish 5804 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5805 
      self.success.write(oprot)
5806 
      oprot.writeFieldEnd()
3431 rajveer 5807 
    if self.ucex is not None:
559 chandransh 5808 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5809 
      self.ucex.write(oprot)
94 ashish 5810 
      oprot.writeFieldEnd()
5811 
    oprot.writeFieldStop()
5812 
    oprot.writeStructEnd()
5813 
 
3431 rajveer 5814 
  def validate(self):
5815 
    return
5816 
 
5817 
 
94 ashish 5818 
  def __repr__(self):
5819 
    L = ['%s=%r' % (key, value)
5820 
      for key, value in self.__dict__.iteritems()]
5821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5822 
 
5823 
  def __eq__(self, other):
5824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5825 
 
5826 
  def __ne__(self, other):
5827 
    return not (self == other)
5828 
 
5326 rajveer 5829 
class createUser_args:
94 ashish 5830 
  """
5831 
  Attributes:
559 chandransh 5832 
   - user
94 ashish 5833 
  """
5834 
 
5835 
  thrift_spec = (
5836 
    None, # 0
559 chandransh 5837 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5838 
  )
5839 
 
559 chandransh 5840 
  def __init__(self, user=None,):
5841 
    self.user = user
94 ashish 5842 
 
5843 
  def read(self, iprot):
5844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5846 
      return
5847 
    iprot.readStructBegin()
5848 
    while True:
5849 
      (fname, ftype, fid) = iprot.readFieldBegin()
5850 
      if ftype == TType.STOP:
5851 
        break
5852 
      if fid == 1:
559 chandransh 5853 
        if ftype == TType.STRUCT:
5854 
          self.user = User()
5855 
          self.user.read(iprot)
94 ashish 5856 
        else:
5857 
          iprot.skip(ftype)
5858 
      else:
5859 
        iprot.skip(ftype)
5860 
      iprot.readFieldEnd()
5861 
    iprot.readStructEnd()
5862 
 
5863 
  def write(self, oprot):
5864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5866 
      return
5326 rajveer 5867 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5868 
    if self.user is not None:
559 chandransh 5869 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5870 
      self.user.write(oprot)
94 ashish 5871 
      oprot.writeFieldEnd()
5872 
    oprot.writeFieldStop()
5873 
    oprot.writeStructEnd()
5874 
 
3431 rajveer 5875 
  def validate(self):
5876 
    return
5877 
 
5878 
 
94 ashish 5879 
  def __repr__(self):
5880 
    L = ['%s=%r' % (key, value)
5881 
      for key, value in self.__dict__.iteritems()]
5882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5883 
 
5884 
  def __eq__(self, other):
5885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5886 
 
5887 
  def __ne__(self, other):
5888 
    return not (self == other)
5889 
 
5326 rajveer 5890 
class createUser_result:
94 ashish 5891 
  """
5892 
  Attributes:
5893 
   - success
559 chandransh 5894 
   - ucex
94 ashish 5895 
  """
5896 
 
5897 
  thrift_spec = (
559 chandransh 5898 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5899 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5900 
  )
5901 
 
559 chandransh 5902 
  def __init__(self, success=None, ucex=None,):
94 ashish 5903 
    self.success = success
559 chandransh 5904 
    self.ucex = ucex
94 ashish 5905 
 
5906 
  def read(self, iprot):
5907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5909 
      return
5910 
    iprot.readStructBegin()
5911 
    while True:
5912 
      (fname, ftype, fid) = iprot.readFieldBegin()
5913 
      if ftype == TType.STOP:
5914 
        break
5915 
      if fid == 0:
5916 
        if ftype == TType.STRUCT:
559 chandransh 5917 
          self.success = User()
94 ashish 5918 
          self.success.read(iprot)
5919 
        else:
5920 
          iprot.skip(ftype)
5921 
      elif fid == 1:
5922 
        if ftype == TType.STRUCT:
559 chandransh 5923 
          self.ucex = UserContextException()
5924 
          self.ucex.read(iprot)
94 ashish 5925 
        else:
5926 
          iprot.skip(ftype)
5927 
      else:
5928 
        iprot.skip(ftype)
5929 
      iprot.readFieldEnd()
5930 
    iprot.readStructEnd()
5931 
 
5932 
  def write(self, oprot):
5933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5935 
      return
5326 rajveer 5936 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5937 
    if self.success is not None:
94 ashish 5938 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5939 
      self.success.write(oprot)
5940 
      oprot.writeFieldEnd()
3431 rajveer 5941 
    if self.ucex is not None:
559 chandransh 5942 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5943 
      self.ucex.write(oprot)
94 ashish 5944 
      oprot.writeFieldEnd()
5945 
    oprot.writeFieldStop()
5946 
    oprot.writeStructEnd()
5947 
 
3431 rajveer 5948 
  def validate(self):
5949 
    return
5950 
 
5951 
 
94 ashish 5952 
  def __repr__(self):
5953 
    L = ['%s=%r' % (key, value)
5954 
      for key, value in self.__dict__.iteritems()]
5955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5956 
 
5957 
  def __eq__(self, other):
5958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5959 
 
5960 
  def __ne__(self, other):
5961 
    return not (self == other)
5962 
 
5326 rajveer 5963 
class updateUser_args:
94 ashish 5964 
  """
5965 
  Attributes:
5326 rajveer 5966 
   - user
94 ashish 5967 
  """
5968 
 
5969 
  thrift_spec = (
5970 
    None, # 0
5326 rajveer 5971 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5972 
  )
5973 
 
5326 rajveer 5974 
  def __init__(self, user=None,):
5975 
    self.user = user
94 ashish 5976 
 
5977 
  def read(self, iprot):
5978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5980 
      return
5981 
    iprot.readStructBegin()
5982 
    while True:
5983 
      (fname, ftype, fid) = iprot.readFieldBegin()
5984 
      if ftype == TType.STOP:
5985 
        break
5986 
      if fid == 1:
5326 rajveer 5987 
        if ftype == TType.STRUCT:
5988 
          self.user = User()
5989 
          self.user.read(iprot)
94 ashish 5990 
        else:
5991 
          iprot.skip(ftype)
5992 
      else:
5993 
        iprot.skip(ftype)
5994 
      iprot.readFieldEnd()
5995 
    iprot.readStructEnd()
5996 
 
5997 
  def write(self, oprot):
5998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6000 
      return
5326 rajveer 6001 
    oprot.writeStructBegin('updateUser_args')
6002 
    if self.user is not None:
6003 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
6004 
      self.user.write(oprot)
94 ashish 6005 
      oprot.writeFieldEnd()
6006 
    oprot.writeFieldStop()
6007 
    oprot.writeStructEnd()
6008 
 
3431 rajveer 6009 
  def validate(self):
6010 
    return
6011 
 
6012 
 
94 ashish 6013 
  def __repr__(self):
6014 
    L = ['%s=%r' % (key, value)
6015 
      for key, value in self.__dict__.iteritems()]
6016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6017 
 
6018 
  def __eq__(self, other):
6019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6020 
 
6021 
  def __ne__(self, other):
6022 
    return not (self == other)
6023 
 
5326 rajveer 6024 
class updateUser_result:
94 ashish 6025 
  """
6026 
  Attributes:
6027 
   - success
559 chandransh 6028 
   - ucex
94 ashish 6029 
  """
6030 
 
6031 
  thrift_spec = (
5326 rajveer 6032 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 6033 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 6034 
  )
6035 
 
559 chandransh 6036 
  def __init__(self, success=None, ucex=None,):
94 ashish 6037 
    self.success = success
559 chandransh 6038 
    self.ucex = ucex
94 ashish 6039 
 
6040 
  def read(self, iprot):
6041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6043 
      return
6044 
    iprot.readStructBegin()
6045 
    while True:
6046 
      (fname, ftype, fid) = iprot.readFieldBegin()
6047 
      if ftype == TType.STOP:
6048 
        break
6049 
      if fid == 0:
5326 rajveer 6050 
        if ftype == TType.STRUCT:
6051 
          self.success = User()
6052 
          self.success.read(iprot)
94 ashish 6053 
        else:
6054 
          iprot.skip(ftype)
6055 
      elif fid == 1:
6056 
        if ftype == TType.STRUCT:
559 chandransh 6057 
          self.ucex = UserContextException()
6058 
          self.ucex.read(iprot)
94 ashish 6059 
        else:
6060 
          iprot.skip(ftype)
6061 
      else:
6062 
        iprot.skip(ftype)
6063 
      iprot.readFieldEnd()
6064 
    iprot.readStructEnd()
6065 
 
6066 
  def write(self, oprot):
6067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6069 
      return
5326 rajveer 6070 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6071 
    if self.success is not None:
5326 rajveer 6072 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6073 
      self.success.write(oprot)
94 ashish 6074 
      oprot.writeFieldEnd()
3431 rajveer 6075 
    if self.ucex is not None:
559 chandransh 6076 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6077 
      self.ucex.write(oprot)
94 ashish 6078 
      oprot.writeFieldEnd()
6079 
    oprot.writeFieldStop()
6080 
    oprot.writeStructEnd()
6081 
 
3431 rajveer 6082 
  def validate(self):
6083 
    return
6084 
 
6085 
 
94 ashish 6086 
  def __repr__(self):
6087 
    L = ['%s=%r' % (key, value)
6088 
      for key, value in self.__dict__.iteritems()]
6089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6090 
 
6091 
  def __eq__(self, other):
6092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6093 
 
6094 
  def __ne__(self, other):
6095 
    return not (self == other)
6096 
 
559 chandransh 6097 
class authenticateUser_args:
94 ashish 6098 
  """
6099 
  Attributes:
6100 
   - email
6101 
   - password
6102 
  """
6103 
 
6104 
  thrift_spec = (
6105 
    None, # 0
6106 
    (1, TType.STRING, 'email', None, None, ), # 1
6107 
    (2, TType.STRING, 'password', None, None, ), # 2
6108 
  )
6109 
 
6110 
  def __init__(self, email=None, password=None,):
6111 
    self.email = email
6112 
    self.password = password
6113 
 
6114 
  def read(self, iprot):
6115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6117 
      return
6118 
    iprot.readStructBegin()
6119 
    while True:
6120 
      (fname, ftype, fid) = iprot.readFieldBegin()
6121 
      if ftype == TType.STOP:
6122 
        break
6123 
      if fid == 1:
6124 
        if ftype == TType.STRING:
6125 
          self.email = iprot.readString();
6126 
        else:
6127 
          iprot.skip(ftype)
6128 
      elif fid == 2:
6129 
        if ftype == TType.STRING:
6130 
          self.password = iprot.readString();
6131 
        else:
6132 
          iprot.skip(ftype)
6133 
      else:
6134 
        iprot.skip(ftype)
6135 
      iprot.readFieldEnd()
6136 
    iprot.readStructEnd()
6137 
 
6138 
  def write(self, oprot):
6139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6141 
      return
559 chandransh 6142 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6143 
    if self.email is not None:
94 ashish 6144 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6145 
      oprot.writeString(self.email)
6146 
      oprot.writeFieldEnd()
3431 rajveer 6147 
    if self.password is not None:
94 ashish 6148 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6149 
      oprot.writeString(self.password)
6150 
      oprot.writeFieldEnd()
6151 
    oprot.writeFieldStop()
6152 
    oprot.writeStructEnd()
6153 
 
3431 rajveer 6154 
  def validate(self):
6155 
    return
6156 
 
6157 
 
94 ashish 6158 
  def __repr__(self):
6159 
    L = ['%s=%r' % (key, value)
6160 
      for key, value in self.__dict__.iteritems()]
6161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6162 
 
6163 
  def __eq__(self, other):
6164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6165 
 
6166 
  def __ne__(self, other):
6167 
    return not (self == other)
6168 
 
559 chandransh 6169 
class authenticateUser_result:
94 ashish 6170 
  """
6171 
  Attributes:
6172 
   - success
559 chandransh 6173 
   - auex
94 ashish 6174 
  """
6175 
 
6176 
  thrift_spec = (
559 chandransh 6177 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6178 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6179 
  )
6180 
 
559 chandransh 6181 
  def __init__(self, success=None, auex=None,):
94 ashish 6182 
    self.success = success
559 chandransh 6183 
    self.auex = auex
94 ashish 6184 
 
6185 
  def read(self, iprot):
6186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6188 
      return
6189 
    iprot.readStructBegin()
6190 
    while True:
6191 
      (fname, ftype, fid) = iprot.readFieldBegin()
6192 
      if ftype == TType.STOP:
6193 
        break
6194 
      if fid == 0:
6195 
        if ftype == TType.STRUCT:
559 chandransh 6196 
          self.success = User()
94 ashish 6197 
          self.success.read(iprot)
6198 
        else:
6199 
          iprot.skip(ftype)
6200 
      elif fid == 1:
6201 
        if ftype == TType.STRUCT:
559 chandransh 6202 
          self.auex = AuthenticationException()
6203 
          self.auex.read(iprot)
94 ashish 6204 
        else:
6205 
          iprot.skip(ftype)
6206 
      else:
6207 
        iprot.skip(ftype)
6208 
      iprot.readFieldEnd()
6209 
    iprot.readStructEnd()
6210 
 
6211 
  def write(self, oprot):
6212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6214 
      return
559 chandransh 6215 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6216 
    if self.success is not None:
94 ashish 6217 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6218 
      self.success.write(oprot)
6219 
      oprot.writeFieldEnd()
3431 rajveer 6220 
    if self.auex is not None:
559 chandransh 6221 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6222 
      self.auex.write(oprot)
94 ashish 6223 
      oprot.writeFieldEnd()
6224 
    oprot.writeFieldStop()
6225 
    oprot.writeStructEnd()
6226 
 
3431 rajveer 6227 
  def validate(self):
6228 
    return
6229 
 
6230 
 
94 ashish 6231 
  def __repr__(self):
6232 
    L = ['%s=%r' % (key, value)
6233 
      for key, value in self.__dict__.iteritems()]
6234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6235 
 
6236 
  def __eq__(self, other):
6237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6238 
 
6239 
  def __ne__(self, other):
6240 
    return not (self == other)
6241 
 
559 chandransh 6242 
class userExists_args:
122 ashish 6243 
  """
6244 
  Attributes:
559 chandransh 6245 
   - email
122 ashish 6246 
  """
6247 
 
6248 
  thrift_spec = (
6249 
    None, # 0
559 chandransh 6250 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6251 
  )
6252 
 
559 chandransh 6253 
  def __init__(self, email=None,):
6254 
    self.email = email
122 ashish 6255 
 
6256 
  def read(self, iprot):
6257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6259 
      return
6260 
    iprot.readStructBegin()
6261 
    while True:
6262 
      (fname, ftype, fid) = iprot.readFieldBegin()
6263 
      if ftype == TType.STOP:
6264 
        break
6265 
      if fid == 1:
6266 
        if ftype == TType.STRING:
559 chandransh 6267 
          self.email = iprot.readString();
122 ashish 6268 
        else:
6269 
          iprot.skip(ftype)
559 chandransh 6270 
      else:
6271 
        iprot.skip(ftype)
6272 
      iprot.readFieldEnd()
6273 
    iprot.readStructEnd()
6274 
 
6275 
  def write(self, oprot):
6276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6278 
      return
6279 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6280 
    if self.email is not None:
559 chandransh 6281 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6282 
      oprot.writeString(self.email)
6283 
      oprot.writeFieldEnd()
6284 
    oprot.writeFieldStop()
6285 
    oprot.writeStructEnd()
6286 
 
3431 rajveer 6287 
  def validate(self):
6288 
    return
6289 
 
6290 
 
559 chandransh 6291 
  def __repr__(self):
6292 
    L = ['%s=%r' % (key, value)
6293 
      for key, value in self.__dict__.iteritems()]
6294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6295 
 
6296 
  def __eq__(self, other):
6297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6298 
 
6299 
  def __ne__(self, other):
6300 
    return not (self == other)
6301 
 
6302 
class userExists_result:
6303 
  """
6304 
  Attributes:
6305 
   - success
6306 
   - ucx
6307 
  """
6308 
 
6309 
  thrift_spec = (
6310 
    (0, TType.BOOL, 'success', None, None, ), # 0
6311 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6312 
  )
6313 
 
6314 
  def __init__(self, success=None, ucx=None,):
6315 
    self.success = success
6316 
    self.ucx = ucx
6317 
 
6318 
  def read(self, iprot):
6319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6321 
      return
6322 
    iprot.readStructBegin()
6323 
    while True:
6324 
      (fname, ftype, fid) = iprot.readFieldBegin()
6325 
      if ftype == TType.STOP:
6326 
        break
6327 
      if fid == 0:
6328 
        if ftype == TType.BOOL:
6329 
          self.success = iprot.readBool();
6330 
        else:
6331 
          iprot.skip(ftype)
6332 
      elif fid == 1:
6333 
        if ftype == TType.STRUCT:
6334 
          self.ucx = UserContextException()
6335 
          self.ucx.read(iprot)
6336 
        else:
6337 
          iprot.skip(ftype)
6338 
      else:
6339 
        iprot.skip(ftype)
6340 
      iprot.readFieldEnd()
6341 
    iprot.readStructEnd()
6342 
 
6343 
  def write(self, oprot):
6344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6346 
      return
6347 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6348 
    if self.success is not None:
559 chandransh 6349 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6350 
      oprot.writeBool(self.success)
6351 
      oprot.writeFieldEnd()
3431 rajveer 6352 
    if self.ucx is not None:
559 chandransh 6353 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6354 
      self.ucx.write(oprot)
6355 
      oprot.writeFieldEnd()
6356 
    oprot.writeFieldStop()
6357 
    oprot.writeStructEnd()
6358 
 
3431 rajveer 6359 
  def validate(self):
6360 
    return
6361 
 
6362 
 
559 chandransh 6363 
  def __repr__(self):
6364 
    L = ['%s=%r' % (key, value)
6365 
      for key, value in self.__dict__.iteritems()]
6366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6367 
 
6368 
  def __eq__(self, other):
6369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6370 
 
6371 
  def __ne__(self, other):
6372 
    return not (self == other)
6373 
 
6374 
class addAddressForUser_args:
6375 
  """
6376 
  Attributes:
6377 
   - userId
6378 
   - address
6379 
   - setDefault
6380 
  """
6381 
 
6382 
  thrift_spec = (
6383 
    None, # 0
6384 
    (1, TType.I64, 'userId', None, None, ), # 1
6385 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6386 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6387 
  )
6388 
 
567 rajveer 6389 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6390 
    self.userId = userId
6391 
    self.address = address
6392 
    self.setDefault = setDefault
6393 
 
6394 
  def read(self, iprot):
6395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6397 
      return
6398 
    iprot.readStructBegin()
6399 
    while True:
6400 
      (fname, ftype, fid) = iprot.readFieldBegin()
6401 
      if ftype == TType.STOP:
6402 
        break
6403 
      if fid == 1:
6404 
        if ftype == TType.I64:
6405 
          self.userId = iprot.readI64();
6406 
        else:
6407 
          iprot.skip(ftype)
122 ashish 6408 
      elif fid == 2:
559 chandransh 6409 
        if ftype == TType.STRUCT:
6410 
          self.address = Address()
6411 
          self.address.read(iprot)
122 ashish 6412 
        else:
6413 
          iprot.skip(ftype)
6414 
      elif fid == 3:
6415 
        if ftype == TType.BOOL:
559 chandransh 6416 
          self.setDefault = iprot.readBool();
122 ashish 6417 
        else:
6418 
          iprot.skip(ftype)
6419 
      else:
6420 
        iprot.skip(ftype)
6421 
      iprot.readFieldEnd()
6422 
    iprot.readStructEnd()
6423 
 
6424 
  def write(self, oprot):
6425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6427 
      return
559 chandransh 6428 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6429 
    if self.userId is not None:
559 chandransh 6430 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6431 
      oprot.writeI64(self.userId)
122 ashish 6432 
      oprot.writeFieldEnd()
3431 rajveer 6433 
    if self.address is not None:
559 chandransh 6434 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6435 
      self.address.write(oprot)
122 ashish 6436 
      oprot.writeFieldEnd()
3431 rajveer 6437 
    if self.setDefault is not None:
567 rajveer 6438 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6439 
      oprot.writeBool(self.setDefault)
6440 
      oprot.writeFieldEnd()
122 ashish 6441 
    oprot.writeFieldStop()
6442 
    oprot.writeStructEnd()
6443 
 
3431 rajveer 6444 
  def validate(self):
6445 
    return
6446 
 
6447 
 
122 ashish 6448 
  def __repr__(self):
6449 
    L = ['%s=%r' % (key, value)
6450 
      for key, value in self.__dict__.iteritems()]
6451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6452 
 
6453 
  def __eq__(self, other):
6454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6455 
 
6456 
  def __ne__(self, other):
6457 
    return not (self == other)
6458 
 
559 chandransh 6459 
class addAddressForUser_result:
122 ashish 6460 
  """
6461 
  Attributes:
6462 
   - success
559 chandransh 6463 
   - ucx
122 ashish 6464 
  """
6465 
 
6466 
  thrift_spec = (
567 rajveer 6467 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6468 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6469 
  )
6470 
 
559 chandransh 6471 
  def __init__(self, success=None, ucx=None,):
122 ashish 6472 
    self.success = success
559 chandransh 6473 
    self.ucx = ucx
122 ashish 6474 
 
6475 
  def read(self, iprot):
6476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6478 
      return
6479 
    iprot.readStructBegin()
6480 
    while True:
6481 
      (fname, ftype, fid) = iprot.readFieldBegin()
6482 
      if ftype == TType.STOP:
6483 
        break
6484 
      if fid == 0:
567 rajveer 6485 
        if ftype == TType.I64:
6486 
          self.success = iprot.readI64();
122 ashish 6487 
        else:
6488 
          iprot.skip(ftype)
6489 
      elif fid == 1:
6490 
        if ftype == TType.STRUCT:
559 chandransh 6491 
          self.ucx = UserContextException()
6492 
          self.ucx.read(iprot)
122 ashish 6493 
        else:
6494 
          iprot.skip(ftype)
6495 
      else:
6496 
        iprot.skip(ftype)
6497 
      iprot.readFieldEnd()
6498 
    iprot.readStructEnd()
6499 
 
6500 
  def write(self, oprot):
6501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6503 
      return
559 chandransh 6504 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6505 
    if self.success is not None:
567 rajveer 6506 
      oprot.writeFieldBegin('success', TType.I64, 0)
6507 
      oprot.writeI64(self.success)
122 ashish 6508 
      oprot.writeFieldEnd()
3431 rajveer 6509 
    if self.ucx is not None:
559 chandransh 6510 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6511 
      self.ucx.write(oprot)
122 ashish 6512 
      oprot.writeFieldEnd()
6513 
    oprot.writeFieldStop()
6514 
    oprot.writeStructEnd()
6515 
 
3431 rajveer 6516 
  def validate(self):
6517 
    return
6518 
 
6519 
 
122 ashish 6520 
  def __repr__(self):
6521 
    L = ['%s=%r' % (key, value)
6522 
      for key, value in self.__dict__.iteritems()]
6523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6524 
 
6525 
  def __eq__(self, other):
6526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6527 
 
6528 
  def __ne__(self, other):
6529 
    return not (self == other)
6530 
 
559 chandransh 6531 
class removeAddressForUser_args:
94 ashish 6532 
  """
6533 
  Attributes:
559 chandransh 6534 
   - userid
6535 
   - addressId
94 ashish 6536 
  """
6537 
 
6538 
  thrift_spec = (
6539 
    None, # 0
559 chandransh 6540 
    (1, TType.I64, 'userid', None, None, ), # 1
6541 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6542 
  )
6543 
 
559 chandransh 6544 
  def __init__(self, userid=None, addressId=None,):
6545 
    self.userid = userid
6546 
    self.addressId = addressId
94 ashish 6547 
 
6548 
  def read(self, iprot):
6549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6551 
      return
6552 
    iprot.readStructBegin()
6553 
    while True:
6554 
      (fname, ftype, fid) = iprot.readFieldBegin()
6555 
      if ftype == TType.STOP:
6556 
        break
6557 
      if fid == 1:
559 chandransh 6558 
        if ftype == TType.I64:
6559 
          self.userid = iprot.readI64();
94 ashish 6560 
        else:
6561 
          iprot.skip(ftype)
559 chandransh 6562 
      elif fid == 2:
6563 
        if ftype == TType.I64:
6564 
          self.addressId = iprot.readI64();
6565 
        else:
6566 
          iprot.skip(ftype)
94 ashish 6567 
      else:
6568 
        iprot.skip(ftype)
6569 
      iprot.readFieldEnd()
6570 
    iprot.readStructEnd()
6571 
 
6572 
  def write(self, oprot):
6573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6575 
      return
559 chandransh 6576 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6577 
    if self.userid is not None:
559 chandransh 6578 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6579 
      oprot.writeI64(self.userid)
94 ashish 6580 
      oprot.writeFieldEnd()
3431 rajveer 6581 
    if self.addressId is not None:
559 chandransh 6582 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6583 
      oprot.writeI64(self.addressId)
6584 
      oprot.writeFieldEnd()
94 ashish 6585 
    oprot.writeFieldStop()
6586 
    oprot.writeStructEnd()
6587 
 
3431 rajveer 6588 
  def validate(self):
6589 
    return
6590 
 
6591 
 
94 ashish 6592 
  def __repr__(self):
6593 
    L = ['%s=%r' % (key, value)
6594 
      for key, value in self.__dict__.iteritems()]
6595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6596 
 
6597 
  def __eq__(self, other):
6598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6599 
 
6600 
  def __ne__(self, other):
6601 
    return not (self == other)
6602 
 
559 chandransh 6603 
class removeAddressForUser_result:
94 ashish 6604 
  """
6605 
  Attributes:
6606 
   - success
6607 
   - ucx
6608 
  """
6609 
 
6610 
  thrift_spec = (
6611 
    (0, TType.BOOL, 'success', None, None, ), # 0
6612 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6613 
  )
6614 
 
6615 
  def __init__(self, success=None, ucx=None,):
6616 
    self.success = success
6617 
    self.ucx = ucx
6618 
 
6619 
  def read(self, iprot):
6620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6622 
      return
6623 
    iprot.readStructBegin()
6624 
    while True:
6625 
      (fname, ftype, fid) = iprot.readFieldBegin()
6626 
      if ftype == TType.STOP:
6627 
        break
6628 
      if fid == 0:
6629 
        if ftype == TType.BOOL:
6630 
          self.success = iprot.readBool();
6631 
        else:
6632 
          iprot.skip(ftype)
6633 
      elif fid == 1:
6634 
        if ftype == TType.STRUCT:
6635 
          self.ucx = UserContextException()
6636 
          self.ucx.read(iprot)
6637 
        else:
6638 
          iprot.skip(ftype)
6639 
      else:
6640 
        iprot.skip(ftype)
6641 
      iprot.readFieldEnd()
6642 
    iprot.readStructEnd()
6643 
 
6644 
  def write(self, oprot):
6645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6647 
      return
559 chandransh 6648 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6649 
    if self.success is not None:
94 ashish 6650 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6651 
      oprot.writeBool(self.success)
6652 
      oprot.writeFieldEnd()
3431 rajveer 6653 
    if self.ucx is not None:
94 ashish 6654 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6655 
      self.ucx.write(oprot)
6656 
      oprot.writeFieldEnd()
6657 
    oprot.writeFieldStop()
6658 
    oprot.writeStructEnd()
6659 
 
3431 rajveer 6660 
  def validate(self):
6661 
    return
6662 
 
6663 
 
94 ashish 6664 
  def __repr__(self):
6665 
    L = ['%s=%r' % (key, value)
6666 
      for key, value in self.__dict__.iteritems()]
6667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6668 
 
6669 
  def __eq__(self, other):
6670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6671 
 
6672 
  def __ne__(self, other):
6673 
    return not (self == other)
6674 
 
559 chandransh 6675 
class setUserAsLoggedIn_args:
94 ashish 6676 
  """
6677 
  Attributes:
559 chandransh 6678 
   - userId
94 ashish 6679 
   - timestamp
6680 
  """
6681 
 
6682 
  thrift_spec = (
6683 
    None, # 0
559 chandransh 6684 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6685 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6686 
  )
6687 
 
559 chandransh 6688 
  def __init__(self, userId=None, timestamp=None,):
6689 
    self.userId = userId
94 ashish 6690 
    self.timestamp = timestamp
6691 
 
6692 
  def read(self, iprot):
6693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6695 
      return
6696 
    iprot.readStructBegin()
6697 
    while True:
6698 
      (fname, ftype, fid) = iprot.readFieldBegin()
6699 
      if ftype == TType.STOP:
6700 
        break
6701 
      if fid == 1:
559 chandransh 6702 
        if ftype == TType.I64:
6703 
          self.userId = iprot.readI64();
94 ashish 6704 
        else:
6705 
          iprot.skip(ftype)
6706 
      elif fid == 2:
6707 
        if ftype == TType.I64:
6708 
          self.timestamp = iprot.readI64();
6709 
        else:
6710 
          iprot.skip(ftype)
6711 
      else:
6712 
        iprot.skip(ftype)
6713 
      iprot.readFieldEnd()
6714 
    iprot.readStructEnd()
6715 
 
6716 
  def write(self, oprot):
6717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6719 
      return
559 chandransh 6720 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6721 
    if self.userId is not None:
559 chandransh 6722 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6723 
      oprot.writeI64(self.userId)
94 ashish 6724 
      oprot.writeFieldEnd()
3431 rajveer 6725 
    if self.timestamp is not None:
94 ashish 6726 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6727 
      oprot.writeI64(self.timestamp)
6728 
      oprot.writeFieldEnd()
6729 
    oprot.writeFieldStop()
6730 
    oprot.writeStructEnd()
6731 
 
3431 rajveer 6732 
  def validate(self):
6733 
    return
6734 
 
6735 
 
94 ashish 6736 
  def __repr__(self):
6737 
    L = ['%s=%r' % (key, value)
6738 
      for key, value in self.__dict__.iteritems()]
6739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6740 
 
6741 
  def __eq__(self, other):
6742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6743 
 
6744 
  def __ne__(self, other):
6745 
    return not (self == other)
6746 
 
559 chandransh 6747 
class setUserAsLoggedIn_result:
94 ashish 6748 
  """
6749 
  Attributes:
6750 
   - success
6751 
   - ucx
6752 
  """
6753 
 
6754 
  thrift_spec = (
6755 
    (0, TType.BOOL, 'success', None, None, ), # 0
6756 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6757 
  )
6758 
 
6759 
  def __init__(self, success=None, ucx=None,):
6760 
    self.success = success
6761 
    self.ucx = ucx
6762 
 
6763 
  def read(self, iprot):
6764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6766 
      return
6767 
    iprot.readStructBegin()
6768 
    while True:
6769 
      (fname, ftype, fid) = iprot.readFieldBegin()
6770 
      if ftype == TType.STOP:
6771 
        break
6772 
      if fid == 0:
6773 
        if ftype == TType.BOOL:
6774 
          self.success = iprot.readBool();
6775 
        else:
6776 
          iprot.skip(ftype)
6777 
      elif fid == 1:
6778 
        if ftype == TType.STRUCT:
6779 
          self.ucx = UserContextException()
6780 
          self.ucx.read(iprot)
6781 
        else:
6782 
          iprot.skip(ftype)
6783 
      else:
6784 
        iprot.skip(ftype)
6785 
      iprot.readFieldEnd()
6786 
    iprot.readStructEnd()
6787 
 
6788 
  def write(self, oprot):
6789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6791 
      return
559 chandransh 6792 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6793 
    if self.success is not None:
94 ashish 6794 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6795 
      oprot.writeBool(self.success)
6796 
      oprot.writeFieldEnd()
3431 rajveer 6797 
    if self.ucx is not None:
94 ashish 6798 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6799 
      self.ucx.write(oprot)
6800 
      oprot.writeFieldEnd()
6801 
    oprot.writeFieldStop()
6802 
    oprot.writeStructEnd()
6803 
 
3431 rajveer 6804 
  def validate(self):
6805 
    return
6806 
 
6807 
 
94 ashish 6808 
  def __repr__(self):
6809 
    L = ['%s=%r' % (key, value)
6810 
      for key, value in self.__dict__.iteritems()]
6811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6812 
 
6813 
  def __eq__(self, other):
6814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6815 
 
6816 
  def __ne__(self, other):
6817 
    return not (self == other)
6818 
 
559 chandransh 6819 
class setUserAsLoggedOut_args:
94 ashish 6820 
  """
6821 
  Attributes:
6822 
   - userid
6823 
   - timestamp
6824 
  """
6825 
 
6826 
  thrift_spec = (
6827 
    None, # 0
559 chandransh 6828 
    (1, TType.I64, 'userid', None, None, ), # 1
6829 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6830 
  )
6831 
 
559 chandransh 6832 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6833 
    self.userid = userid
6834 
    self.timestamp = timestamp
6835 
 
6836 
  def read(self, iprot):
6837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6839 
      return
6840 
    iprot.readStructBegin()
6841 
    while True:
6842 
      (fname, ftype, fid) = iprot.readFieldBegin()
6843 
      if ftype == TType.STOP:
6844 
        break
6845 
      if fid == 1:
6846 
        if ftype == TType.I64:
6847 
          self.userid = iprot.readI64();
6848 
        else:
6849 
          iprot.skip(ftype)
559 chandransh 6850 
      elif fid == 2:
94 ashish 6851 
        if ftype == TType.I64:
6852 
          self.timestamp = iprot.readI64();
6853 
        else:
6854 
          iprot.skip(ftype)
6855 
      else:
6856 
        iprot.skip(ftype)
6857 
      iprot.readFieldEnd()
6858 
    iprot.readStructEnd()
6859 
 
6860 
  def write(self, oprot):
6861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6863 
      return
559 chandransh 6864 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6865 
    if self.userid is not None:
559 chandransh 6866 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6867 
      oprot.writeI64(self.userid)
6868 
      oprot.writeFieldEnd()
3431 rajveer 6869 
    if self.timestamp is not None:
559 chandransh 6870 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6871 
      oprot.writeI64(self.timestamp)
6872 
      oprot.writeFieldEnd()
6873 
    oprot.writeFieldStop()
6874 
    oprot.writeStructEnd()
6875 
 
3431 rajveer 6876 
  def validate(self):
6877 
    return
6878 
 
6879 
 
94 ashish 6880 
  def __repr__(self):
6881 
    L = ['%s=%r' % (key, value)
6882 
      for key, value in self.__dict__.iteritems()]
6883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6884 
 
6885 
  def __eq__(self, other):
6886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6887 
 
6888 
  def __ne__(self, other):
6889 
    return not (self == other)
6890 
 
559 chandransh 6891 
class setUserAsLoggedOut_result:
94 ashish 6892 
  """
6893 
  Attributes:
6894 
   - success
6895 
   - ucx
6896 
  """
6897 
 
6898 
  thrift_spec = (
6899 
    (0, TType.BOOL, 'success', None, None, ), # 0
6900 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6901 
  )
6902 
 
6903 
  def __init__(self, success=None, ucx=None,):
6904 
    self.success = success
6905 
    self.ucx = ucx
6906 
 
6907 
  def read(self, iprot):
6908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6910 
      return
6911 
    iprot.readStructBegin()
6912 
    while True:
6913 
      (fname, ftype, fid) = iprot.readFieldBegin()
6914 
      if ftype == TType.STOP:
6915 
        break
6916 
      if fid == 0:
6917 
        if ftype == TType.BOOL:
6918 
          self.success = iprot.readBool();
6919 
        else:
6920 
          iprot.skip(ftype)
6921 
      elif fid == 1:
6922 
        if ftype == TType.STRUCT:
6923 
          self.ucx = UserContextException()
6924 
          self.ucx.read(iprot)
6925 
        else:
6926 
          iprot.skip(ftype)
6927 
      else:
6928 
        iprot.skip(ftype)
6929 
      iprot.readFieldEnd()
6930 
    iprot.readStructEnd()
6931 
 
6932 
  def write(self, oprot):
6933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6935 
      return
559 chandransh 6936 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6937 
    if self.success is not None:
94 ashish 6938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6939 
      oprot.writeBool(self.success)
6940 
      oprot.writeFieldEnd()
3431 rajveer 6941 
    if self.ucx is not None:
94 ashish 6942 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6943 
      self.ucx.write(oprot)
6944 
      oprot.writeFieldEnd()
6945 
    oprot.writeFieldStop()
6946 
    oprot.writeStructEnd()
6947 
 
3431 rajveer 6948 
  def validate(self):
6949 
    return
6950 
 
6951 
 
94 ashish 6952 
  def __repr__(self):
6953 
    L = ['%s=%r' % (key, value)
6954 
      for key, value in self.__dict__.iteritems()]
6955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6956 
 
6957 
  def __eq__(self, other):
6958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6959 
 
6960 
  def __ne__(self, other):
6961 
    return not (self == other)
6962 
 
559 chandransh 6963 
class setDefaultAddress_args:
94 ashish 6964 
  """
6965 
  Attributes:
6966 
   - userid
6967 
   - addressId
6968 
  """
6969 
 
6970 
  thrift_spec = (
6971 
    None, # 0
6972 
    (1, TType.I64, 'userid', None, None, ), # 1
6973 
    (2, TType.I64, 'addressId', None, None, ), # 2
6974 
  )
6975 
 
6976 
  def __init__(self, userid=None, addressId=None,):
6977 
    self.userid = userid
6978 
    self.addressId = addressId
6979 
 
6980 
  def read(self, iprot):
6981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6983 
      return
6984 
    iprot.readStructBegin()
6985 
    while True:
6986 
      (fname, ftype, fid) = iprot.readFieldBegin()
6987 
      if ftype == TType.STOP:
6988 
        break
6989 
      if fid == 1:
6990 
        if ftype == TType.I64:
6991 
          self.userid = iprot.readI64();
6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      elif fid == 2:
6995 
        if ftype == TType.I64:
6996 
          self.addressId = iprot.readI64();
6997 
        else:
6998 
          iprot.skip(ftype)
6999 
      else:
7000 
        iprot.skip(ftype)
7001 
      iprot.readFieldEnd()
7002 
    iprot.readStructEnd()
7003 
 
7004 
  def write(self, oprot):
7005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7007 
      return
559 chandransh 7008 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 7009 
    if self.userid is not None:
94 ashish 7010 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7011 
      oprot.writeI64(self.userid)
7012 
      oprot.writeFieldEnd()
3431 rajveer 7013 
    if self.addressId is not None:
94 ashish 7014 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
7015 
      oprot.writeI64(self.addressId)
7016 
      oprot.writeFieldEnd()
7017 
    oprot.writeFieldStop()
7018 
    oprot.writeStructEnd()
7019 
 
3431 rajveer 7020 
  def validate(self):
7021 
    return
7022 
 
7023 
 
94 ashish 7024 
  def __repr__(self):
7025 
    L = ['%s=%r' % (key, value)
7026 
      for key, value in self.__dict__.iteritems()]
7027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7028 
 
7029 
  def __eq__(self, other):
7030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7031 
 
7032 
  def __ne__(self, other):
7033 
    return not (self == other)
7034 
 
559 chandransh 7035 
class setDefaultAddress_result:
94 ashish 7036 
  """
7037 
  Attributes:
7038 
   - success
7039 
   - ucx
7040 
  """
7041 
 
7042 
  thrift_spec = (
7043 
    (0, TType.BOOL, 'success', None, None, ), # 0
7044 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7045 
  )
7046 
 
7047 
  def __init__(self, success=None, ucx=None,):
7048 
    self.success = success
7049 
    self.ucx = ucx
7050 
 
7051 
  def read(self, iprot):
7052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7054 
      return
7055 
    iprot.readStructBegin()
7056 
    while True:
7057 
      (fname, ftype, fid) = iprot.readFieldBegin()
7058 
      if ftype == TType.STOP:
7059 
        break
7060 
      if fid == 0:
7061 
        if ftype == TType.BOOL:
7062 
          self.success = iprot.readBool();
7063 
        else:
7064 
          iprot.skip(ftype)
7065 
      elif fid == 1:
7066 
        if ftype == TType.STRUCT:
7067 
          self.ucx = UserContextException()
7068 
          self.ucx.read(iprot)
7069 
        else:
7070 
          iprot.skip(ftype)
7071 
      else:
7072 
        iprot.skip(ftype)
7073 
      iprot.readFieldEnd()
7074 
    iprot.readStructEnd()
7075 
 
7076 
  def write(self, oprot):
7077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7079 
      return
559 chandransh 7080 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7081 
    if self.success is not None:
94 ashish 7082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7083 
      oprot.writeBool(self.success)
7084 
      oprot.writeFieldEnd()
3431 rajveer 7085 
    if self.ucx is not None:
94 ashish 7086 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7087 
      self.ucx.write(oprot)
7088 
      oprot.writeFieldEnd()
7089 
    oprot.writeFieldStop()
7090 
    oprot.writeStructEnd()
7091 
 
3431 rajveer 7092 
  def validate(self):
7093 
    return
7094 
 
7095 
 
94 ashish 7096 
  def __repr__(self):
7097 
    L = ['%s=%r' % (key, value)
7098 
      for key, value in self.__dict__.iteritems()]
7099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7100 
 
7101 
  def __eq__(self, other):
7102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7103 
 
7104 
  def __ne__(self, other):
7105 
    return not (self == other)
7106 
 
559 chandransh 7107 
class updatePassword_args:
94 ashish 7108 
  """
7109 
  Attributes:
559 chandransh 7110 
   - userid
594 rajveer 7111 
   - oldPassword
7112 
   - newPassword
94 ashish 7113 
  """
7114 
 
7115 
  thrift_spec = (
7116 
    None, # 0
559 chandransh 7117 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7118 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7119 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7120 
  )
7121 
 
594 rajveer 7122 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7123 
    self.userid = userid
594 rajveer 7124 
    self.oldPassword = oldPassword
7125 
    self.newPassword = newPassword
94 ashish 7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 1:
7137 
        if ftype == TType.I64:
559 chandransh 7138 
          self.userid = iprot.readI64();
94 ashish 7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      elif fid == 2:
559 chandransh 7142 
        if ftype == TType.STRING:
594 rajveer 7143 
          self.oldPassword = iprot.readString();
94 ashish 7144 
        else:
7145 
          iprot.skip(ftype)
594 rajveer 7146 
      elif fid == 3:
7147 
        if ftype == TType.STRING:
7148 
          self.newPassword = iprot.readString();
7149 
        else:
7150 
          iprot.skip(ftype)
94 ashish 7151 
      else:
7152 
        iprot.skip(ftype)
7153 
      iprot.readFieldEnd()
7154 
    iprot.readStructEnd()
7155 
 
7156 
  def write(self, oprot):
7157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7159 
      return
559 chandransh 7160 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7161 
    if self.userid is not None:
559 chandransh 7162 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7163 
      oprot.writeI64(self.userid)
94 ashish 7164 
      oprot.writeFieldEnd()
3431 rajveer 7165 
    if self.oldPassword is not None:
594 rajveer 7166 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7167 
      oprot.writeString(self.oldPassword)
94 ashish 7168 
      oprot.writeFieldEnd()
3431 rajveer 7169 
    if self.newPassword is not None:
594 rajveer 7170 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7171 
      oprot.writeString(self.newPassword)
7172 
      oprot.writeFieldEnd()
94 ashish 7173 
    oprot.writeFieldStop()
7174 
    oprot.writeStructEnd()
7175 
 
3431 rajveer 7176 
  def validate(self):
7177 
    return
7178 
 
7179 
 
94 ashish 7180 
  def __repr__(self):
7181 
    L = ['%s=%r' % (key, value)
7182 
      for key, value in self.__dict__.iteritems()]
7183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7184 
 
7185 
  def __eq__(self, other):
7186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7187 
 
7188 
  def __ne__(self, other):
7189 
    return not (self == other)
7190 
 
559 chandransh 7191 
class updatePassword_result:
94 ashish 7192 
  """
7193 
  Attributes:
7194 
   - success
7195 
   - ucx
7196 
  """
7197 
 
7198 
  thrift_spec = (
7199 
    (0, TType.BOOL, 'success', None, None, ), # 0
7200 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7201 
  )
7202 
 
7203 
  def __init__(self, success=None, ucx=None,):
7204 
    self.success = success
7205 
    self.ucx = ucx
7206 
 
7207 
  def read(self, iprot):
7208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7210 
      return
7211 
    iprot.readStructBegin()
7212 
    while True:
7213 
      (fname, ftype, fid) = iprot.readFieldBegin()
7214 
      if ftype == TType.STOP:
7215 
        break
7216 
      if fid == 0:
7217 
        if ftype == TType.BOOL:
7218 
          self.success = iprot.readBool();
7219 
        else:
7220 
          iprot.skip(ftype)
7221 
      elif fid == 1:
7222 
        if ftype == TType.STRUCT:
7223 
          self.ucx = UserContextException()
7224 
          self.ucx.read(iprot)
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      else:
7228 
        iprot.skip(ftype)
7229 
      iprot.readFieldEnd()
7230 
    iprot.readStructEnd()
7231 
 
7232 
  def write(self, oprot):
7233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7235 
      return
559 chandransh 7236 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7237 
    if self.success is not None:
94 ashish 7238 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7239 
      oprot.writeBool(self.success)
7240 
      oprot.writeFieldEnd()
3431 rajveer 7241 
    if self.ucx is not None:
94 ashish 7242 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7243 
      self.ucx.write(oprot)
7244 
      oprot.writeFieldEnd()
7245 
    oprot.writeFieldStop()
7246 
    oprot.writeStructEnd()
7247 
 
3431 rajveer 7248 
  def validate(self):
7249 
    return
7250 
 
7251 
 
94 ashish 7252 
  def __repr__(self):
7253 
    L = ['%s=%r' % (key, value)
7254 
      for key, value in self.__dict__.iteritems()]
7255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7256 
 
7257 
  def __eq__(self, other):
7258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7259 
 
7260 
  def __ne__(self, other):
7261 
    return not (self == other)
7262 
 
581 rajveer 7263 
class forgotPassword_args:
7264 
  """
7265 
  Attributes:
7266 
   - email
884 rajveer 7267 
   - newPassword
581 rajveer 7268 
  """
7269 
 
7270 
  thrift_spec = (
7271 
    None, # 0
7272 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7273 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7274 
  )
7275 
 
884 rajveer 7276 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7277 
    self.email = email
884 rajveer 7278 
    self.newPassword = newPassword
581 rajveer 7279 
 
7280 
  def read(self, iprot):
7281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7283 
      return
7284 
    iprot.readStructBegin()
7285 
    while True:
7286 
      (fname, ftype, fid) = iprot.readFieldBegin()
7287 
      if ftype == TType.STOP:
7288 
        break
7289 
      if fid == 1:
7290 
        if ftype == TType.STRING:
7291 
          self.email = iprot.readString();
7292 
        else:
7293 
          iprot.skip(ftype)
884 rajveer 7294 
      elif fid == 2:
7295 
        if ftype == TType.STRING:
7296 
          self.newPassword = iprot.readString();
7297 
        else:
7298 
          iprot.skip(ftype)
581 rajveer 7299 
      else:
7300 
        iprot.skip(ftype)
7301 
      iprot.readFieldEnd()
7302 
    iprot.readStructEnd()
7303 
 
7304 
  def write(self, oprot):
7305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7307 
      return
7308 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7309 
    if self.email is not None:
581 rajveer 7310 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7311 
      oprot.writeString(self.email)
7312 
      oprot.writeFieldEnd()
3431 rajveer 7313 
    if self.newPassword is not None:
884 rajveer 7314 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7315 
      oprot.writeString(self.newPassword)
7316 
      oprot.writeFieldEnd()
581 rajveer 7317 
    oprot.writeFieldStop()
7318 
    oprot.writeStructEnd()
7319 
 
3431 rajveer 7320 
  def validate(self):
7321 
    return
7322 
 
7323 
 
581 rajveer 7324 
  def __repr__(self):
7325 
    L = ['%s=%r' % (key, value)
7326 
      for key, value in self.__dict__.iteritems()]
7327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7328 
 
7329 
  def __eq__(self, other):
7330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7331 
 
7332 
  def __ne__(self, other):
7333 
    return not (self == other)
7334 
 
7335 
class forgotPassword_result:
7336 
  """
7337 
  Attributes:
7338 
   - success
7339 
   - ucx
7340 
  """
7341 
 
7342 
  thrift_spec = (
7343 
    (0, TType.BOOL, 'success', None, None, ), # 0
7344 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7345 
  )
7346 
 
7347 
  def __init__(self, success=None, ucx=None,):
7348 
    self.success = success
7349 
    self.ucx = ucx
7350 
 
7351 
  def read(self, iprot):
7352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7354 
      return
7355 
    iprot.readStructBegin()
7356 
    while True:
7357 
      (fname, ftype, fid) = iprot.readFieldBegin()
7358 
      if ftype == TType.STOP:
7359 
        break
7360 
      if fid == 0:
7361 
        if ftype == TType.BOOL:
7362 
          self.success = iprot.readBool();
7363 
        else:
7364 
          iprot.skip(ftype)
7365 
      elif fid == 1:
7366 
        if ftype == TType.STRUCT:
7367 
          self.ucx = UserContextException()
7368 
          self.ucx.read(iprot)
7369 
        else:
7370 
          iprot.skip(ftype)
7371 
      else:
7372 
        iprot.skip(ftype)
7373 
      iprot.readFieldEnd()
7374 
    iprot.readStructEnd()
7375 
 
7376 
  def write(self, oprot):
7377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7379 
      return
7380 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7381 
    if self.success is not None:
581 rajveer 7382 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7383 
      oprot.writeBool(self.success)
7384 
      oprot.writeFieldEnd()
3431 rajveer 7385 
    if self.ucx is not None:
581 rajveer 7386 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7387 
      self.ucx.write(oprot)
7388 
      oprot.writeFieldEnd()
7389 
    oprot.writeFieldStop()
7390 
    oprot.writeStructEnd()
7391 
 
3431 rajveer 7392 
  def validate(self):
7393 
    return
7394 
 
7395 
 
581 rajveer 7396 
  def __repr__(self):
7397 
    L = ['%s=%r' % (key, value)
7398 
      for key, value in self.__dict__.iteritems()]
7399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7400 
 
7401 
  def __eq__(self, other):
7402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7403 
 
7404 
  def __ne__(self, other):
7405 
    return not (self == other)
7406 
 
594 rajveer 7407 
class getAllAddressesForUser_args:
7408 
  """
7409 
  Attributes:
7410 
   - userId
7411 
  """
7412 
 
7413 
  thrift_spec = (
7414 
    None, # 0
7415 
    (1, TType.I64, 'userId', None, None, ), # 1
7416 
  )
7417 
 
7418 
  def __init__(self, userId=None,):
7419 
    self.userId = userId
7420 
 
7421 
  def read(self, iprot):
7422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7424 
      return
7425 
    iprot.readStructBegin()
7426 
    while True:
7427 
      (fname, ftype, fid) = iprot.readFieldBegin()
7428 
      if ftype == TType.STOP:
7429 
        break
7430 
      if fid == 1:
7431 
        if ftype == TType.I64:
7432 
          self.userId = iprot.readI64();
7433 
        else:
7434 
          iprot.skip(ftype)
7435 
      else:
7436 
        iprot.skip(ftype)
7437 
      iprot.readFieldEnd()
7438 
    iprot.readStructEnd()
7439 
 
7440 
  def write(self, oprot):
7441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7443 
      return
7444 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7445 
    if self.userId is not None:
594 rajveer 7446 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7447 
      oprot.writeI64(self.userId)
7448 
      oprot.writeFieldEnd()
7449 
    oprot.writeFieldStop()
7450 
    oprot.writeStructEnd()
7451 
 
3431 rajveer 7452 
  def validate(self):
7453 
    return
7454 
 
7455 
 
594 rajveer 7456 
  def __repr__(self):
7457 
    L = ['%s=%r' % (key, value)
7458 
      for key, value in self.__dict__.iteritems()]
7459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7460 
 
7461 
  def __eq__(self, other):
7462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7463 
 
7464 
  def __ne__(self, other):
7465 
    return not (self == other)
7466 
 
7467 
class getAllAddressesForUser_result:
7468 
  """
7469 
  Attributes:
7470 
   - success
7471 
   - ucx
7472 
  """
7473 
 
7474 
  thrift_spec = (
7475 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7476 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7477 
  )
7478 
 
7479 
  def __init__(self, success=None, ucx=None,):
7480 
    self.success = success
7481 
    self.ucx = ucx
7482 
 
7483 
  def read(self, iprot):
7484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7486 
      return
7487 
    iprot.readStructBegin()
7488 
    while True:
7489 
      (fname, ftype, fid) = iprot.readFieldBegin()
7490 
      if ftype == TType.STOP:
7491 
        break
7492 
      if fid == 0:
7493 
        if ftype == TType.LIST:
7494 
          self.success = []
11592 amit.gupta 7495 
          (_etype100, _size97) = iprot.readListBegin()
7496 
          for _i101 in xrange(_size97):
7497 
            _elem102 = Address()
7498 
            _elem102.read(iprot)
7499 
            self.success.append(_elem102)
594 rajveer 7500 
          iprot.readListEnd()
7501 
        else:
7502 
          iprot.skip(ftype)
7503 
      elif fid == 1:
7504 
        if ftype == TType.STRUCT:
7505 
          self.ucx = UserContextException()
7506 
          self.ucx.read(iprot)
7507 
        else:
7508 
          iprot.skip(ftype)
7509 
      else:
7510 
        iprot.skip(ftype)
7511 
      iprot.readFieldEnd()
7512 
    iprot.readStructEnd()
7513 
 
7514 
  def write(self, oprot):
7515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7517 
      return
7518 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7519 
    if self.success is not None:
594 rajveer 7520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7522 
      for iter103 in self.success:
7523 
        iter103.write(oprot)
594 rajveer 7524 
      oprot.writeListEnd()
7525 
      oprot.writeFieldEnd()
3431 rajveer 7526 
    if self.ucx is not None:
594 rajveer 7527 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7528 
      self.ucx.write(oprot)
7529 
      oprot.writeFieldEnd()
7530 
    oprot.writeFieldStop()
7531 
    oprot.writeStructEnd()
7532 
 
3431 rajveer 7533 
  def validate(self):
7534 
    return
7535 
 
7536 
 
594 rajveer 7537 
  def __repr__(self):
7538 
    L = ['%s=%r' % (key, value)
7539 
      for key, value in self.__dict__.iteritems()]
7540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7541 
 
7542 
  def __eq__(self, other):
7543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7544 
 
7545 
  def __ne__(self, other):
7546 
    return not (self == other)
7547 
 
1894 vikas 7548 
class getAddressById_args:
7549 
  """
7550 
  Attributes:
7551 
   - addressId
7552 
  """
7553 
 
7554 
  thrift_spec = (
7555 
    None, # 0
7556 
    (1, TType.I64, 'addressId', None, None, ), # 1
7557 
  )
7558 
 
7559 
  def __init__(self, addressId=None,):
7560 
    self.addressId = addressId
7561 
 
7562 
  def read(self, iprot):
7563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7565 
      return
7566 
    iprot.readStructBegin()
7567 
    while True:
7568 
      (fname, ftype, fid) = iprot.readFieldBegin()
7569 
      if ftype == TType.STOP:
7570 
        break
7571 
      if fid == 1:
7572 
        if ftype == TType.I64:
7573 
          self.addressId = iprot.readI64();
7574 
        else:
7575 
          iprot.skip(ftype)
7576 
      else:
7577 
        iprot.skip(ftype)
7578 
      iprot.readFieldEnd()
7579 
    iprot.readStructEnd()
7580 
 
7581 
  def write(self, oprot):
7582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7584 
      return
7585 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7586 
    if self.addressId is not None:
1894 vikas 7587 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7588 
      oprot.writeI64(self.addressId)
7589 
      oprot.writeFieldEnd()
7590 
    oprot.writeFieldStop()
7591 
    oprot.writeStructEnd()
7592 
 
3431 rajveer 7593 
  def validate(self):
7594 
    return
7595 
 
7596 
 
1894 vikas 7597 
  def __repr__(self):
7598 
    L = ['%s=%r' % (key, value)
7599 
      for key, value in self.__dict__.iteritems()]
7600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7601 
 
7602 
  def __eq__(self, other):
7603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7604 
 
7605 
  def __ne__(self, other):
7606 
    return not (self == other)
7607 
 
7608 
class getAddressById_result:
7609 
  """
7610 
  Attributes:
7611 
   - success
7612 
   - ucx
7613 
  """
7614 
 
7615 
  thrift_spec = (
7616 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7617 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7618 
  )
7619 
 
7620 
  def __init__(self, success=None, ucx=None,):
7621 
    self.success = success
7622 
    self.ucx = ucx
7623 
 
7624 
  def read(self, iprot):
7625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7627 
      return
7628 
    iprot.readStructBegin()
7629 
    while True:
7630 
      (fname, ftype, fid) = iprot.readFieldBegin()
7631 
      if ftype == TType.STOP:
7632 
        break
7633 
      if fid == 0:
7634 
        if ftype == TType.STRUCT:
7635 
          self.success = Address()
7636 
          self.success.read(iprot)
7637 
        else:
7638 
          iprot.skip(ftype)
7639 
      elif fid == 1:
7640 
        if ftype == TType.STRUCT:
7641 
          self.ucx = UserContextException()
7642 
          self.ucx.read(iprot)
7643 
        else:
7644 
          iprot.skip(ftype)
7645 
      else:
7646 
        iprot.skip(ftype)
7647 
      iprot.readFieldEnd()
7648 
    iprot.readStructEnd()
7649 
 
7650 
  def write(self, oprot):
7651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7653 
      return
7654 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7655 
    if self.success is not None:
1894 vikas 7656 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7657 
      self.success.write(oprot)
7658 
      oprot.writeFieldEnd()
3431 rajveer 7659 
    if self.ucx is not None:
1894 vikas 7660 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7661 
      self.ucx.write(oprot)
7662 
      oprot.writeFieldEnd()
7663 
    oprot.writeFieldStop()
7664 
    oprot.writeStructEnd()
7665 
 
3431 rajveer 7666 
  def validate(self):
7667 
    return
7668 
 
7669 
 
1894 vikas 7670 
  def __repr__(self):
7671 
    L = ['%s=%r' % (key, value)
7672 
      for key, value in self.__dict__.iteritems()]
7673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7674 
 
7675 
  def __eq__(self, other):
7676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7677 
 
7678 
  def __ne__(self, other):
7679 
    return not (self == other)
7680 
 
594 rajveer 7681 
class getDefaultAddressId_args:
7682 
  """
7683 
  Attributes:
7684 
   - userId
7685 
  """
7686 
 
7687 
  thrift_spec = (
7688 
    None, # 0
7689 
    (1, TType.I64, 'userId', None, None, ), # 1
7690 
  )
7691 
 
7692 
  def __init__(self, userId=None,):
7693 
    self.userId = userId
7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 1:
7705 
        if ftype == TType.I64:
7706 
          self.userId = iprot.readI64();
7707 
        else:
7708 
          iprot.skip(ftype)
7709 
      else:
7710 
        iprot.skip(ftype)
7711 
      iprot.readFieldEnd()
7712 
    iprot.readStructEnd()
7713 
 
7714 
  def write(self, oprot):
7715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7717 
      return
7718 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7719 
    if self.userId is not None:
594 rajveer 7720 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7721 
      oprot.writeI64(self.userId)
7722 
      oprot.writeFieldEnd()
7723 
    oprot.writeFieldStop()
7724 
    oprot.writeStructEnd()
7725 
 
3431 rajveer 7726 
  def validate(self):
7727 
    return
7728 
 
7729 
 
594 rajveer 7730 
  def __repr__(self):
7731 
    L = ['%s=%r' % (key, value)
7732 
      for key, value in self.__dict__.iteritems()]
7733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7734 
 
7735 
  def __eq__(self, other):
7736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7737 
 
7738 
  def __ne__(self, other):
7739 
    return not (self == other)
7740 
 
7741 
class getDefaultAddressId_result:
7742 
  """
7743 
  Attributes:
7744 
   - success
7745 
   - ucx
7746 
  """
7747 
 
7748 
  thrift_spec = (
7749 
    (0, TType.I64, 'success', None, None, ), # 0
7750 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7751 
  )
7752 
 
7753 
  def __init__(self, success=None, ucx=None,):
7754 
    self.success = success
7755 
    self.ucx = ucx
7756 
 
7757 
  def read(self, iprot):
7758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7760 
      return
7761 
    iprot.readStructBegin()
7762 
    while True:
7763 
      (fname, ftype, fid) = iprot.readFieldBegin()
7764 
      if ftype == TType.STOP:
7765 
        break
7766 
      if fid == 0:
7767 
        if ftype == TType.I64:
7768 
          self.success = iprot.readI64();
7769 
        else:
7770 
          iprot.skip(ftype)
7771 
      elif fid == 1:
7772 
        if ftype == TType.STRUCT:
7773 
          self.ucx = UserContextException()
7774 
          self.ucx.read(iprot)
7775 
        else:
7776 
          iprot.skip(ftype)
7777 
      else:
7778 
        iprot.skip(ftype)
7779 
      iprot.readFieldEnd()
7780 
    iprot.readStructEnd()
7781 
 
7782 
  def write(self, oprot):
7783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7785 
      return
7786 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7787 
    if self.success is not None:
594 rajveer 7788 
      oprot.writeFieldBegin('success', TType.I64, 0)
7789 
      oprot.writeI64(self.success)
7790 
      oprot.writeFieldEnd()
3431 rajveer 7791 
    if self.ucx is not None:
594 rajveer 7792 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7793 
      self.ucx.write(oprot)
7794 
      oprot.writeFieldEnd()
7795 
    oprot.writeFieldStop()
7796 
    oprot.writeStructEnd()
7797 
 
3431 rajveer 7798 
  def validate(self):
7799 
    return
7800 
 
7801 
 
594 rajveer 7802 
  def __repr__(self):
7803 
    L = ['%s=%r' % (key, value)
7804 
      for key, value in self.__dict__.iteritems()]
7805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7806 
 
7807 
  def __eq__(self, other):
7808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7809 
 
7810 
  def __ne__(self, other):
7811 
    return not (self == other)
7812 
 
785 rajveer 7813 
class getDefaultPincode_args:
7814 
  """
7815 
  Attributes:
7816 
   - userId
7817 
  """
7818 
 
7819 
  thrift_spec = (
7820 
    None, # 0
7821 
    (1, TType.I64, 'userId', None, None, ), # 1
7822 
  )
7823 
 
7824 
  def __init__(self, userId=None,):
7825 
    self.userId = userId
7826 
 
7827 
  def read(self, iprot):
7828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7830 
      return
7831 
    iprot.readStructBegin()
7832 
    while True:
7833 
      (fname, ftype, fid) = iprot.readFieldBegin()
7834 
      if ftype == TType.STOP:
7835 
        break
7836 
      if fid == 1:
7837 
        if ftype == TType.I64:
7838 
          self.userId = iprot.readI64();
7839 
        else:
7840 
          iprot.skip(ftype)
7841 
      else:
7842 
        iprot.skip(ftype)
7843 
      iprot.readFieldEnd()
7844 
    iprot.readStructEnd()
7845 
 
7846 
  def write(self, oprot):
7847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7849 
      return
7850 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7851 
    if self.userId is not None:
785 rajveer 7852 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7853 
      oprot.writeI64(self.userId)
7854 
      oprot.writeFieldEnd()
7855 
    oprot.writeFieldStop()
7856 
    oprot.writeStructEnd()
7857 
 
3431 rajveer 7858 
  def validate(self):
7859 
    return
7860 
 
7861 
 
785 rajveer 7862 
  def __repr__(self):
7863 
    L = ['%s=%r' % (key, value)
7864 
      for key, value in self.__dict__.iteritems()]
7865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7866 
 
7867 
  def __eq__(self, other):
7868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7869 
 
7870 
  def __ne__(self, other):
7871 
    return not (self == other)
7872 
 
7873 
class getDefaultPincode_result:
7874 
  """
7875 
  Attributes:
7876 
   - success
7877 
   - ucx
7878 
  """
7879 
 
7880 
  thrift_spec = (
7881 
    (0, TType.STRING, 'success', None, None, ), # 0
7882 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7883 
  )
7884 
 
7885 
  def __init__(self, success=None, ucx=None,):
7886 
    self.success = success
7887 
    self.ucx = ucx
7888 
 
7889 
  def read(self, iprot):
7890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7892 
      return
7893 
    iprot.readStructBegin()
7894 
    while True:
7895 
      (fname, ftype, fid) = iprot.readFieldBegin()
7896 
      if ftype == TType.STOP:
7897 
        break
7898 
      if fid == 0:
7899 
        if ftype == TType.STRING:
7900 
          self.success = iprot.readString();
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 1:
7904 
        if ftype == TType.STRUCT:
7905 
          self.ucx = UserContextException()
7906 
          self.ucx.read(iprot)
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
7918 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7919 
    if self.success is not None:
785 rajveer 7920 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7921 
      oprot.writeString(self.success)
7922 
      oprot.writeFieldEnd()
3431 rajveer 7923 
    if self.ucx is not None:
785 rajveer 7924 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7925 
      self.ucx.write(oprot)
7926 
      oprot.writeFieldEnd()
7927 
    oprot.writeFieldStop()
7928 
    oprot.writeStructEnd()
7929 
 
3431 rajveer 7930 
  def validate(self):
7931 
    return
7932 
 
7933 
 
785 rajveer 7934 
  def __repr__(self):
7935 
    L = ['%s=%r' % (key, value)
7936 
      for key, value in self.__dict__.iteritems()]
7937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7938 
 
7939 
  def __eq__(self, other):
7940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7941 
 
7942 
  def __ne__(self, other):
7943 
    return not (self == other)
7944 
 
1274 varun.gupt 7945 
class saveUserCommunication_args:
7946 
  """
7947 
  Attributes:
7948 
   - userId
7949 
   - replyTo
7950 
   - communicationType
7951 
   - orderId
7952 
   - airwaybillNo
7953 
   - productName
7954 
   - subject
7955 
   - message
7956 
  """
7957 
 
7958 
  thrift_spec = (
7959 
    None, # 0
7960 
    (1, TType.I64, 'userId', None, None, ), # 1
7961 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7962 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7963 
    (4, TType.I64, 'orderId', None, None, ), # 4
7964 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7965 
    (6, TType.STRING, 'productName', None, None, ), # 6
7966 
    (7, TType.STRING, 'subject', None, None, ), # 7
7967 
    (8, TType.STRING, 'message', None, None, ), # 8
7968 
  )
7969 
 
7970 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7971 
    self.userId = userId
7972 
    self.replyTo = replyTo
7973 
    self.communicationType = communicationType
7974 
    self.orderId = orderId
7975 
    self.airwaybillNo = airwaybillNo
7976 
    self.productName = productName
7977 
    self.subject = subject
7978 
    self.message = message
7979 
 
7980 
  def read(self, iprot):
7981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7983 
      return
7984 
    iprot.readStructBegin()
7985 
    while True:
7986 
      (fname, ftype, fid) = iprot.readFieldBegin()
7987 
      if ftype == TType.STOP:
7988 
        break
7989 
      if fid == 1:
7990 
        if ftype == TType.I64:
7991 
          self.userId = iprot.readI64();
7992 
        else:
7993 
          iprot.skip(ftype)
7994 
      elif fid == 2:
7995 
        if ftype == TType.STRING:
7996 
          self.replyTo = iprot.readString();
7997 
        else:
7998 
          iprot.skip(ftype)
7999 
      elif fid == 3:
8000 
        if ftype == TType.I64:
8001 
          self.communicationType = iprot.readI64();
8002 
        else:
8003 
          iprot.skip(ftype)
8004 
      elif fid == 4:
8005 
        if ftype == TType.I64:
8006 
          self.orderId = iprot.readI64();
8007 
        else:
8008 
          iprot.skip(ftype)
8009 
      elif fid == 5:
8010 
        if ftype == TType.STRING:
8011 
          self.airwaybillNo = iprot.readString();
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      elif fid == 6:
8015 
        if ftype == TType.STRING:
8016 
          self.productName = iprot.readString();
8017 
        else:
8018 
          iprot.skip(ftype)
8019 
      elif fid == 7:
8020 
        if ftype == TType.STRING:
8021 
          self.subject = iprot.readString();
8022 
        else:
8023 
          iprot.skip(ftype)
8024 
      elif fid == 8:
8025 
        if ftype == TType.STRING:
8026 
          self.message = iprot.readString();
8027 
        else:
8028 
          iprot.skip(ftype)
8029 
      else:
8030 
        iprot.skip(ftype)
8031 
      iprot.readFieldEnd()
8032 
    iprot.readStructEnd()
8033 
 
8034 
  def write(self, oprot):
8035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8037 
      return
8038 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 8039 
    if self.userId is not None:
1274 varun.gupt 8040 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8041 
      oprot.writeI64(self.userId)
8042 
      oprot.writeFieldEnd()
3431 rajveer 8043 
    if self.replyTo is not None:
1274 varun.gupt 8044 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
8045 
      oprot.writeString(self.replyTo)
8046 
      oprot.writeFieldEnd()
3431 rajveer 8047 
    if self.communicationType is not None:
1274 varun.gupt 8048 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8049 
      oprot.writeI64(self.communicationType)
8050 
      oprot.writeFieldEnd()
3431 rajveer 8051 
    if self.orderId is not None:
1274 varun.gupt 8052 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8053 
      oprot.writeI64(self.orderId)
8054 
      oprot.writeFieldEnd()
3431 rajveer 8055 
    if self.airwaybillNo is not None:
1274 varun.gupt 8056 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8057 
      oprot.writeString(self.airwaybillNo)
8058 
      oprot.writeFieldEnd()
3431 rajveer 8059 
    if self.productName is not None:
1274 varun.gupt 8060 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8061 
      oprot.writeString(self.productName)
8062 
      oprot.writeFieldEnd()
3431 rajveer 8063 
    if self.subject is not None:
1274 varun.gupt 8064 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8065 
      oprot.writeString(self.subject)
8066 
      oprot.writeFieldEnd()
3431 rajveer 8067 
    if self.message is not None:
1274 varun.gupt 8068 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8069 
      oprot.writeString(self.message)
8070 
      oprot.writeFieldEnd()
8071 
    oprot.writeFieldStop()
8072 
    oprot.writeStructEnd()
8073 
 
3431 rajveer 8074 
  def validate(self):
8075 
    return
8076 
 
8077 
 
1274 varun.gupt 8078 
  def __repr__(self):
8079 
    L = ['%s=%r' % (key, value)
8080 
      for key, value in self.__dict__.iteritems()]
8081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8082 
 
8083 
  def __eq__(self, other):
8084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8085 
 
8086 
  def __ne__(self, other):
8087 
    return not (self == other)
8088 
 
8089 
class saveUserCommunication_result:
8090 
  """
8091 
  Attributes:
8092 
   - success
8093 
   - ucx
8094 
  """
8095 
 
8096 
  thrift_spec = (
8097 
    (0, TType.BOOL, 'success', None, None, ), # 0
8098 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8099 
  )
8100 
 
8101 
  def __init__(self, success=None, ucx=None,):
8102 
    self.success = success
8103 
    self.ucx = ucx
8104 
 
8105 
  def read(self, iprot):
8106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8108 
      return
8109 
    iprot.readStructBegin()
8110 
    while True:
8111 
      (fname, ftype, fid) = iprot.readFieldBegin()
8112 
      if ftype == TType.STOP:
8113 
        break
8114 
      if fid == 0:
8115 
        if ftype == TType.BOOL:
8116 
          self.success = iprot.readBool();
8117 
        else:
8118 
          iprot.skip(ftype)
8119 
      elif fid == 1:
8120 
        if ftype == TType.STRUCT:
8121 
          self.ucx = UserCommunicationException()
8122 
          self.ucx.read(iprot)
8123 
        else:
8124 
          iprot.skip(ftype)
8125 
      else:
8126 
        iprot.skip(ftype)
8127 
      iprot.readFieldEnd()
8128 
    iprot.readStructEnd()
8129 
 
8130 
  def write(self, oprot):
8131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8133 
      return
8134 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8135 
    if self.success is not None:
1274 varun.gupt 8136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8137 
      oprot.writeBool(self.success)
8138 
      oprot.writeFieldEnd()
3431 rajveer 8139 
    if self.ucx is not None:
1274 varun.gupt 8140 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8141 
      self.ucx.write(oprot)
8142 
      oprot.writeFieldEnd()
8143 
    oprot.writeFieldStop()
8144 
    oprot.writeStructEnd()
8145 
 
3431 rajveer 8146 
  def validate(self):
8147 
    return
8148 
 
8149 
 
1274 varun.gupt 8150 
  def __repr__(self):
8151 
    L = ['%s=%r' % (key, value)
8152 
      for key, value in self.__dict__.iteritems()]
8153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8154 
 
8155 
  def __eq__(self, other):
8156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8157 
 
8158 
  def __ne__(self, other):
8159 
    return not (self == other)
8160 
 
1590 varun.gupt 8161 
class getUserCommunicationById_args:
8162 
  """
8163 
  Attributes:
8164 
   - id
8165 
  """
8166 
 
8167 
  thrift_spec = (
8168 
    None, # 0
8169 
    (1, TType.I64, 'id', None, None, ), # 1
8170 
  )
8171 
 
8172 
  def __init__(self, id=None,):
8173 
    self.id = id
8174 
 
8175 
  def read(self, iprot):
8176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8178 
      return
8179 
    iprot.readStructBegin()
8180 
    while True:
8181 
      (fname, ftype, fid) = iprot.readFieldBegin()
8182 
      if ftype == TType.STOP:
8183 
        break
8184 
      if fid == 1:
8185 
        if ftype == TType.I64:
8186 
          self.id = iprot.readI64();
8187 
        else:
8188 
          iprot.skip(ftype)
8189 
      else:
8190 
        iprot.skip(ftype)
8191 
      iprot.readFieldEnd()
8192 
    iprot.readStructEnd()
8193 
 
8194 
  def write(self, oprot):
8195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8197 
      return
8198 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8199 
    if self.id is not None:
1590 varun.gupt 8200 
      oprot.writeFieldBegin('id', TType.I64, 1)
8201 
      oprot.writeI64(self.id)
8202 
      oprot.writeFieldEnd()
8203 
    oprot.writeFieldStop()
8204 
    oprot.writeStructEnd()
8205 
 
3431 rajveer 8206 
  def validate(self):
8207 
    return
8208 
 
8209 
 
1590 varun.gupt 8210 
  def __repr__(self):
8211 
    L = ['%s=%r' % (key, value)
8212 
      for key, value in self.__dict__.iteritems()]
8213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8214 
 
8215 
  def __eq__(self, other):
8216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8217 
 
8218 
  def __ne__(self, other):
8219 
    return not (self == other)
8220 
 
8221 
class getUserCommunicationById_result:
8222 
  """
8223 
  Attributes:
8224 
   - success
8225 
   - ucx
8226 
  """
8227 
 
8228 
  thrift_spec = (
8229 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8230 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8231 
  )
8232 
 
8233 
  def __init__(self, success=None, ucx=None,):
8234 
    self.success = success
8235 
    self.ucx = ucx
8236 
 
8237 
  def read(self, iprot):
8238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8240 
      return
8241 
    iprot.readStructBegin()
8242 
    while True:
8243 
      (fname, ftype, fid) = iprot.readFieldBegin()
8244 
      if ftype == TType.STOP:
8245 
        break
8246 
      if fid == 0:
8247 
        if ftype == TType.STRUCT:
8248 
          self.success = UserCommunication()
8249 
          self.success.read(iprot)
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      elif fid == 1:
8253 
        if ftype == TType.STRUCT:
8254 
          self.ucx = UserCommunicationException()
8255 
          self.ucx.read(iprot)
8256 
        else:
8257 
          iprot.skip(ftype)
8258 
      else:
8259 
        iprot.skip(ftype)
8260 
      iprot.readFieldEnd()
8261 
    iprot.readStructEnd()
8262 
 
8263 
  def write(self, oprot):
8264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8266 
      return
8267 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8268 
    if self.success is not None:
1590 varun.gupt 8269 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8270 
      self.success.write(oprot)
8271 
      oprot.writeFieldEnd()
3431 rajveer 8272 
    if self.ucx is not None:
1590 varun.gupt 8273 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8274 
      self.ucx.write(oprot)
8275 
      oprot.writeFieldEnd()
8276 
    oprot.writeFieldStop()
8277 
    oprot.writeStructEnd()
8278 
 
3431 rajveer 8279 
  def validate(self):
8280 
    return
8281 
 
8282 
 
1590 varun.gupt 8283 
  def __repr__(self):
8284 
    L = ['%s=%r' % (key, value)
8285 
      for key, value in self.__dict__.iteritems()]
8286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8287 
 
8288 
  def __eq__(self, other):
8289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8290 
 
8291 
  def __ne__(self, other):
8292 
    return not (self == other)
8293 
 
8294 
class getUserCommunicationByUser_args:
8295 
  """
8296 
  Attributes:
8297 
   - userId
8298 
  """
8299 
 
8300 
  thrift_spec = (
8301 
    None, # 0
8302 
    (1, TType.I64, 'userId', None, None, ), # 1
8303 
  )
8304 
 
8305 
  def __init__(self, userId=None,):
8306 
    self.userId = userId
8307 
 
8308 
  def read(self, iprot):
8309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8311 
      return
8312 
    iprot.readStructBegin()
8313 
    while True:
8314 
      (fname, ftype, fid) = iprot.readFieldBegin()
8315 
      if ftype == TType.STOP:
8316 
        break
8317 
      if fid == 1:
8318 
        if ftype == TType.I64:
8319 
          self.userId = iprot.readI64();
8320 
        else:
8321 
          iprot.skip(ftype)
8322 
      else:
8323 
        iprot.skip(ftype)
8324 
      iprot.readFieldEnd()
8325 
    iprot.readStructEnd()
8326 
 
8327 
  def write(self, oprot):
8328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8330 
      return
8331 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8332 
    if self.userId is not None:
1590 varun.gupt 8333 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8334 
      oprot.writeI64(self.userId)
8335 
      oprot.writeFieldEnd()
8336 
    oprot.writeFieldStop()
8337 
    oprot.writeStructEnd()
8338 
 
3431 rajveer 8339 
  def validate(self):
8340 
    return
8341 
 
8342 
 
1590 varun.gupt 8343 
  def __repr__(self):
8344 
    L = ['%s=%r' % (key, value)
8345 
      for key, value in self.__dict__.iteritems()]
8346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8347 
 
8348 
  def __eq__(self, other):
8349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8350 
 
8351 
  def __ne__(self, other):
8352 
    return not (self == other)
8353 
 
8354 
class getUserCommunicationByUser_result:
8355 
  """
8356 
  Attributes:
8357 
   - success
8358 
   - ucx
8359 
  """
8360 
 
8361 
  thrift_spec = (
8362 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8363 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8364 
  )
8365 
 
8366 
  def __init__(self, success=None, ucx=None,):
8367 
    self.success = success
8368 
    self.ucx = ucx
8369 
 
8370 
  def read(self, iprot):
8371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8373 
      return
8374 
    iprot.readStructBegin()
8375 
    while True:
8376 
      (fname, ftype, fid) = iprot.readFieldBegin()
8377 
      if ftype == TType.STOP:
8378 
        break
8379 
      if fid == 0:
8380 
        if ftype == TType.LIST:
8381 
          self.success = []
11592 amit.gupta 8382 
          (_etype107, _size104) = iprot.readListBegin()
8383 
          for _i108 in xrange(_size104):
8384 
            _elem109 = UserCommunication()
8385 
            _elem109.read(iprot)
8386 
            self.success.append(_elem109)
1590 varun.gupt 8387 
          iprot.readListEnd()
8388 
        else:
8389 
          iprot.skip(ftype)
8390 
      elif fid == 1:
8391 
        if ftype == TType.STRUCT:
8392 
          self.ucx = UserCommunicationException()
8393 
          self.ucx.read(iprot)
8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      else:
8397 
        iprot.skip(ftype)
8398 
      iprot.readFieldEnd()
8399 
    iprot.readStructEnd()
8400 
 
8401 
  def write(self, oprot):
8402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8404 
      return
8405 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8406 
    if self.success is not None:
1590 varun.gupt 8407 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8408 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8409 
      for iter110 in self.success:
8410 
        iter110.write(oprot)
1590 varun.gupt 8411 
      oprot.writeListEnd()
8412 
      oprot.writeFieldEnd()
3431 rajveer 8413 
    if self.ucx is not None:
1590 varun.gupt 8414 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8415 
      self.ucx.write(oprot)
8416 
      oprot.writeFieldEnd()
8417 
    oprot.writeFieldStop()
8418 
    oprot.writeStructEnd()
8419 
 
3431 rajveer 8420 
  def validate(self):
8421 
    return
8422 
 
8423 
 
1590 varun.gupt 8424 
  def __repr__(self):
8425 
    L = ['%s=%r' % (key, value)
8426 
      for key, value in self.__dict__.iteritems()]
8427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8428 
 
8429 
  def __eq__(self, other):
8430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8431 
 
8432 
  def __ne__(self, other):
8433 
    return not (self == other)
8434 
 
8435 
class getAllUserCommunications_args:
8436 
 
8437 
  thrift_spec = (
8438 
  )
8439 
 
8440 
  def read(self, iprot):
8441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8443 
      return
8444 
    iprot.readStructBegin()
8445 
    while True:
8446 
      (fname, ftype, fid) = iprot.readFieldBegin()
8447 
      if ftype == TType.STOP:
8448 
        break
8449 
      else:
8450 
        iprot.skip(ftype)
8451 
      iprot.readFieldEnd()
8452 
    iprot.readStructEnd()
8453 
 
8454 
  def write(self, oprot):
8455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8457 
      return
8458 
    oprot.writeStructBegin('getAllUserCommunications_args')
8459 
    oprot.writeFieldStop()
8460 
    oprot.writeStructEnd()
8461 
 
3431 rajveer 8462 
  def validate(self):
8463 
    return
8464 
 
8465 
 
1590 varun.gupt 8466 
  def __repr__(self):
8467 
    L = ['%s=%r' % (key, value)
8468 
      for key, value in self.__dict__.iteritems()]
8469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8470 
 
8471 
  def __eq__(self, other):
8472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8473 
 
8474 
  def __ne__(self, other):
8475 
    return not (self == other)
8476 
 
8477 
class getAllUserCommunications_result:
8478 
  """
8479 
  Attributes:
8480 
   - success
8481 
   - ucx
8482 
  """
8483 
 
8484 
  thrift_spec = (
8485 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8486 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8487 
  )
8488 
 
8489 
  def __init__(self, success=None, ucx=None,):
8490 
    self.success = success
8491 
    self.ucx = ucx
8492 
 
8493 
  def read(self, iprot):
8494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8496 
      return
8497 
    iprot.readStructBegin()
8498 
    while True:
8499 
      (fname, ftype, fid) = iprot.readFieldBegin()
8500 
      if ftype == TType.STOP:
8501 
        break
8502 
      if fid == 0:
8503 
        if ftype == TType.LIST:
8504 
          self.success = []
11592 amit.gupta 8505 
          (_etype114, _size111) = iprot.readListBegin()
8506 
          for _i115 in xrange(_size111):
8507 
            _elem116 = UserCommunication()
8508 
            _elem116.read(iprot)
8509 
            self.success.append(_elem116)
1590 varun.gupt 8510 
          iprot.readListEnd()
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.ucx = UserCommunicationException()
8516 
          self.ucx.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
8528 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8529 
    if self.success is not None:
1590 varun.gupt 8530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8532 
      for iter117 in self.success:
8533 
        iter117.write(oprot)
1590 varun.gupt 8534 
      oprot.writeListEnd()
8535 
      oprot.writeFieldEnd()
3431 rajveer 8536 
    if self.ucx is not None:
1590 varun.gupt 8537 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8538 
      self.ucx.write(oprot)
8539 
      oprot.writeFieldEnd()
8540 
    oprot.writeFieldStop()
8541 
    oprot.writeStructEnd()
8542 
 
3431 rajveer 8543 
  def validate(self):
8544 
    return
8545 
 
8546 
 
1590 varun.gupt 8547 
  def __repr__(self):
8548 
    L = ['%s=%r' % (key, value)
8549 
      for key, value in self.__dict__.iteritems()]
8550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8551 
 
8552 
  def __eq__(self, other):
8553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8554 
 
8555 
  def __ne__(self, other):
8556 
    return not (self == other)
8557 
 
5407 amar.kumar 8558 
class removeUserCommunication_args:
8559 
  """
8560 
  Attributes:
8561 
   - id
8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    None, # 0
8566 
    (1, TType.I64, 'id', None, None, ), # 1
8567 
  )
8568 
 
8569 
  def __init__(self, id=None,):
8570 
    self.id = id
8571 
 
8572 
  def read(self, iprot):
8573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8575 
      return
8576 
    iprot.readStructBegin()
8577 
    while True:
8578 
      (fname, ftype, fid) = iprot.readFieldBegin()
8579 
      if ftype == TType.STOP:
8580 
        break
8581 
      if fid == 1:
8582 
        if ftype == TType.I64:
8583 
          self.id = iprot.readI64();
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      else:
8587 
        iprot.skip(ftype)
8588 
      iprot.readFieldEnd()
8589 
    iprot.readStructEnd()
8590 
 
8591 
  def write(self, oprot):
8592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8594 
      return
8595 
    oprot.writeStructBegin('removeUserCommunication_args')
8596 
    if self.id is not None:
8597 
      oprot.writeFieldBegin('id', TType.I64, 1)
8598 
      oprot.writeI64(self.id)
8599 
      oprot.writeFieldEnd()
8600 
    oprot.writeFieldStop()
8601 
    oprot.writeStructEnd()
8602 
 
8603 
  def validate(self):
8604 
    return
8605 
 
8606 
 
8607 
  def __repr__(self):
8608 
    L = ['%s=%r' % (key, value)
8609 
      for key, value in self.__dict__.iteritems()]
8610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8611 
 
8612 
  def __eq__(self, other):
8613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8614 
 
8615 
  def __ne__(self, other):
8616 
    return not (self == other)
8617 
 
8618 
class removeUserCommunication_result:
8619 
  """
8620 
  Attributes:
8621 
   - ucx
8622 
  """
8623 
 
8624 
  thrift_spec = (
8625 
    None, # 0
8626 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8627 
  )
8628 
 
8629 
  def __init__(self, ucx=None,):
8630 
    self.ucx = ucx
8631 
 
8632 
  def read(self, iprot):
8633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8635 
      return
8636 
    iprot.readStructBegin()
8637 
    while True:
8638 
      (fname, ftype, fid) = iprot.readFieldBegin()
8639 
      if ftype == TType.STOP:
8640 
        break
8641 
      if fid == 1:
8642 
        if ftype == TType.STRUCT:
8643 
          self.ucx = UserCommunicationException()
8644 
          self.ucx.read(iprot)
8645 
        else:
8646 
          iprot.skip(ftype)
8647 
      else:
8648 
        iprot.skip(ftype)
8649 
      iprot.readFieldEnd()
8650 
    iprot.readStructEnd()
8651 
 
8652 
  def write(self, oprot):
8653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8655 
      return
8656 
    oprot.writeStructBegin('removeUserCommunication_result')
8657 
    if self.ucx is not None:
8658 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8659 
      self.ucx.write(oprot)
8660 
      oprot.writeFieldEnd()
8661 
    oprot.writeFieldStop()
8662 
    oprot.writeStructEnd()
8663 
 
8664 
  def validate(self):
8665 
    return
8666 
 
8667 
 
8668 
  def __repr__(self):
8669 
    L = ['%s=%r' % (key, value)
8670 
      for key, value in self.__dict__.iteritems()]
8671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8672 
 
8673 
  def __eq__(self, other):
8674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8675 
 
8676 
  def __ne__(self, other):
8677 
    return not (self == other)
8678 
 
1845 vikas 8679 
class createMasterAffiliate_args:
8680 
  """
8681 
  Attributes:
8682 
   - name
1859 vikas 8683 
   - addedOn
1845 vikas 8684 
  """
8685 
 
8686 
  thrift_spec = (
8687 
    None, # 0
8688 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8689 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8690 
  )
8691 
 
1859 vikas 8692 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8693 
    self.name = name
1859 vikas 8694 
    self.addedOn = addedOn
1845 vikas 8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      if fid == 1:
8706 
        if ftype == TType.STRING:
8707 
          self.name = iprot.readString();
8708 
        else:
8709 
          iprot.skip(ftype)
1859 vikas 8710 
      elif fid == 2:
8711 
        if ftype == TType.I64:
8712 
          self.addedOn = iprot.readI64();
8713 
        else:
8714 
          iprot.skip(ftype)
1845 vikas 8715 
      else:
8716 
        iprot.skip(ftype)
8717 
      iprot.readFieldEnd()
8718 
    iprot.readStructEnd()
8719 
 
8720 
  def write(self, oprot):
8721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8723 
      return
8724 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8725 
    if self.name is not None:
1845 vikas 8726 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8727 
      oprot.writeString(self.name)
8728 
      oprot.writeFieldEnd()
3431 rajveer 8729 
    if self.addedOn is not None:
1859 vikas 8730 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8731 
      oprot.writeI64(self.addedOn)
8732 
      oprot.writeFieldEnd()
1845 vikas 8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
3431 rajveer 8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
1845 vikas 8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
8751 
class createMasterAffiliate_result:
8752 
  """
8753 
  Attributes:
8754 
   - success
8755 
   - utx
8756 
  """
8757 
 
8758 
  thrift_spec = (
8759 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8760 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8761 
  )
8762 
 
8763 
  def __init__(self, success=None, utx=None,):
8764 
    self.success = success
8765 
    self.utx = utx
8766 
 
8767 
  def read(self, iprot):
8768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8770 
      return
8771 
    iprot.readStructBegin()
8772 
    while True:
8773 
      (fname, ftype, fid) = iprot.readFieldBegin()
8774 
      if ftype == TType.STOP:
8775 
        break
8776 
      if fid == 0:
8777 
        if ftype == TType.STRUCT:
8778 
          self.success = MasterAffiliate()
8779 
          self.success.read(iprot)
8780 
        else:
8781 
          iprot.skip(ftype)
8782 
      elif fid == 1:
8783 
        if ftype == TType.STRUCT:
1996 vikas 8784 
          self.utx = UserAffiliateException()
1845 vikas 8785 
          self.utx.read(iprot)
8786 
        else:
8787 
          iprot.skip(ftype)
8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
8797 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8798 
    if self.success is not None:
1845 vikas 8799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8800 
      self.success.write(oprot)
8801 
      oprot.writeFieldEnd()
3431 rajveer 8802 
    if self.utx is not None:
1845 vikas 8803 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8804 
      self.utx.write(oprot)
8805 
      oprot.writeFieldEnd()
8806 
    oprot.writeFieldStop()
8807 
    oprot.writeStructEnd()
8808 
 
3431 rajveer 8809 
  def validate(self):
8810 
    return
8811 
 
8812 
 
1845 vikas 8813 
  def __repr__(self):
8814 
    L = ['%s=%r' % (key, value)
8815 
      for key, value in self.__dict__.iteritems()]
8816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8817 
 
8818 
  def __eq__(self, other):
8819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8820 
 
8821 
  def __ne__(self, other):
8822 
    return not (self == other)
8823 
 
1899 vikas 8824 
class getAllMasterAffiliates_args:
8825 
 
8826 
  thrift_spec = (
8827 
  )
8828 
 
8829 
  def read(self, iprot):
8830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8832 
      return
8833 
    iprot.readStructBegin()
8834 
    while True:
8835 
      (fname, ftype, fid) = iprot.readFieldBegin()
8836 
      if ftype == TType.STOP:
8837 
        break
8838 
      else:
8839 
        iprot.skip(ftype)
8840 
      iprot.readFieldEnd()
8841 
    iprot.readStructEnd()
8842 
 
8843 
  def write(self, oprot):
8844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8846 
      return
8847 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8848 
    oprot.writeFieldStop()
8849 
    oprot.writeStructEnd()
8850 
 
3431 rajveer 8851 
  def validate(self):
8852 
    return
8853 
 
8854 
 
1899 vikas 8855 
  def __repr__(self):
8856 
    L = ['%s=%r' % (key, value)
8857 
      for key, value in self.__dict__.iteritems()]
8858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8859 
 
8860 
  def __eq__(self, other):
8861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8862 
 
8863 
  def __ne__(self, other):
8864 
    return not (self == other)
8865 
 
8866 
class getAllMasterAffiliates_result:
8867 
  """
8868 
  Attributes:
8869 
   - success
8870 
   - utx
8871 
  """
8872 
 
8873 
  thrift_spec = (
8874 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8875 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8876 
  )
8877 
 
8878 
  def __init__(self, success=None, utx=None,):
8879 
    self.success = success
8880 
    self.utx = utx
8881 
 
8882 
  def read(self, iprot):
8883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8885 
      return
8886 
    iprot.readStructBegin()
8887 
    while True:
8888 
      (fname, ftype, fid) = iprot.readFieldBegin()
8889 
      if ftype == TType.STOP:
8890 
        break
8891 
      if fid == 0:
8892 
        if ftype == TType.LIST:
8893 
          self.success = []
11592 amit.gupta 8894 
          (_etype121, _size118) = iprot.readListBegin()
8895 
          for _i122 in xrange(_size118):
8896 
            _elem123 = MasterAffiliate()
8897 
            _elem123.read(iprot)
8898 
            self.success.append(_elem123)
1899 vikas 8899 
          iprot.readListEnd()
8900 
        else:
8901 
          iprot.skip(ftype)
8902 
      elif fid == 1:
8903 
        if ftype == TType.STRUCT:
1996 vikas 8904 
          self.utx = UserAffiliateException()
1899 vikas 8905 
          self.utx.read(iprot)
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
8917 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8918 
    if self.success is not None:
1899 vikas 8919 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8920 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8921 
      for iter124 in self.success:
8922 
        iter124.write(oprot)
1899 vikas 8923 
      oprot.writeListEnd()
8924 
      oprot.writeFieldEnd()
3431 rajveer 8925 
    if self.utx is not None:
1899 vikas 8926 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8927 
      self.utx.write(oprot)
8928 
      oprot.writeFieldEnd()
8929 
    oprot.writeFieldStop()
8930 
    oprot.writeStructEnd()
8931 
 
3431 rajveer 8932 
  def validate(self):
8933 
    return
8934 
 
8935 
 
1899 vikas 8936 
  def __repr__(self):
8937 
    L = ['%s=%r' % (key, value)
8938 
      for key, value in self.__dict__.iteritems()]
8939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8940 
 
8941 
  def __eq__(self, other):
8942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8943 
 
8944 
  def __ne__(self, other):
8945 
    return not (self == other)
8946 
 
1845 vikas 8947 
class getMasterAffiliateById_args:
8948 
  """
8949 
  Attributes:
8950 
   - id
8951 
  """
8952 
 
8953 
  thrift_spec = (
8954 
    None, # 0
8955 
    (1, TType.I64, 'id', None, None, ), # 1
8956 
  )
8957 
 
8958 
  def __init__(self, id=None,):
8959 
    self.id = id
8960 
 
8961 
  def read(self, iprot):
8962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8964 
      return
8965 
    iprot.readStructBegin()
8966 
    while True:
8967 
      (fname, ftype, fid) = iprot.readFieldBegin()
8968 
      if ftype == TType.STOP:
8969 
        break
8970 
      if fid == 1:
8971 
        if ftype == TType.I64:
8972 
          self.id = iprot.readI64();
8973 
        else:
8974 
          iprot.skip(ftype)
8975 
      else:
8976 
        iprot.skip(ftype)
8977 
      iprot.readFieldEnd()
8978 
    iprot.readStructEnd()
8979 
 
8980 
  def write(self, oprot):
8981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8983 
      return
8984 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8985 
    if self.id is not None:
1845 vikas 8986 
      oprot.writeFieldBegin('id', TType.I64, 1)
8987 
      oprot.writeI64(self.id)
8988 
      oprot.writeFieldEnd()
8989 
    oprot.writeFieldStop()
8990 
    oprot.writeStructEnd()
8991 
 
3431 rajveer 8992 
  def validate(self):
8993 
    return
8994 
 
8995 
 
1845 vikas 8996 
  def __repr__(self):
8997 
    L = ['%s=%r' % (key, value)
8998 
      for key, value in self.__dict__.iteritems()]
8999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9000 
 
9001 
  def __eq__(self, other):
9002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9003 
 
9004 
  def __ne__(self, other):
9005 
    return not (self == other)
9006 
 
9007 
class getMasterAffiliateById_result:
9008 
  """
9009 
  Attributes:
9010 
   - success
9011 
   - utx
9012 
  """
9013 
 
9014 
  thrift_spec = (
9015 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9016 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9017 
  )
9018 
 
9019 
  def __init__(self, success=None, utx=None,):
9020 
    self.success = success
9021 
    self.utx = utx
9022 
 
9023 
  def read(self, iprot):
9024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9026 
      return
9027 
    iprot.readStructBegin()
9028 
    while True:
9029 
      (fname, ftype, fid) = iprot.readFieldBegin()
9030 
      if ftype == TType.STOP:
9031 
        break
9032 
      if fid == 0:
9033 
        if ftype == TType.STRUCT:
9034 
          self.success = MasterAffiliate()
9035 
          self.success.read(iprot)
9036 
        else:
9037 
          iprot.skip(ftype)
9038 
      elif fid == 1:
9039 
        if ftype == TType.STRUCT:
1996 vikas 9040 
          self.utx = UserAffiliateException()
1845 vikas 9041 
          self.utx.read(iprot)
9042 
        else:
9043 
          iprot.skip(ftype)
9044 
      else:
9045 
        iprot.skip(ftype)
9046 
      iprot.readFieldEnd()
9047 
    iprot.readStructEnd()
9048 
 
9049 
  def write(self, oprot):
9050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9052 
      return
9053 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9054 
    if self.success is not None:
1845 vikas 9055 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9056 
      self.success.write(oprot)
9057 
      oprot.writeFieldEnd()
3431 rajveer 9058 
    if self.utx is not None:
1845 vikas 9059 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9060 
      self.utx.write(oprot)
9061 
      oprot.writeFieldEnd()
9062 
    oprot.writeFieldStop()
9063 
    oprot.writeStructEnd()
9064 
 
3431 rajveer 9065 
  def validate(self):
9066 
    return
9067 
 
9068 
 
1845 vikas 9069 
  def __repr__(self):
9070 
    L = ['%s=%r' % (key, value)
9071 
      for key, value in self.__dict__.iteritems()]
9072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9073 
 
9074 
  def __eq__(self, other):
9075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9076 
 
9077 
  def __ne__(self, other):
9078 
    return not (self == other)
9079 
 
9080 
class getMasterAffiliateByName_args:
9081 
  """
9082 
  Attributes:
9083 
   - name
9084 
  """
9085 
 
9086 
  thrift_spec = (
9087 
    None, # 0
9088 
    (1, TType.STRING, 'name', None, None, ), # 1
9089 
  )
9090 
 
9091 
  def __init__(self, name=None,):
9092 
    self.name = name
9093 
 
9094 
  def read(self, iprot):
9095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9097 
      return
9098 
    iprot.readStructBegin()
9099 
    while True:
9100 
      (fname, ftype, fid) = iprot.readFieldBegin()
9101 
      if ftype == TType.STOP:
9102 
        break
9103 
      if fid == 1:
9104 
        if ftype == TType.STRING:
9105 
          self.name = iprot.readString();
9106 
        else:
9107 
          iprot.skip(ftype)
9108 
      else:
9109 
        iprot.skip(ftype)
9110 
      iprot.readFieldEnd()
9111 
    iprot.readStructEnd()
9112 
 
9113 
  def write(self, oprot):
9114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9116 
      return
9117 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9118 
    if self.name is not None:
1845 vikas 9119 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9120 
      oprot.writeString(self.name)
9121 
      oprot.writeFieldEnd()
9122 
    oprot.writeFieldStop()
9123 
    oprot.writeStructEnd()
9124 
 
3431 rajveer 9125 
  def validate(self):
9126 
    return
9127 
 
9128 
 
1845 vikas 9129 
  def __repr__(self):
9130 
    L = ['%s=%r' % (key, value)
9131 
      for key, value in self.__dict__.iteritems()]
9132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9133 
 
9134 
  def __eq__(self, other):
9135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9136 
 
9137 
  def __ne__(self, other):
9138 
    return not (self == other)
9139 
 
9140 
class getMasterAffiliateByName_result:
9141 
  """
9142 
  Attributes:
9143 
   - success
9144 
   - utx
9145 
  """
9146 
 
9147 
  thrift_spec = (
9148 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9149 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9150 
  )
9151 
 
9152 
  def __init__(self, success=None, utx=None,):
9153 
    self.success = success
9154 
    self.utx = utx
9155 
 
9156 
  def read(self, iprot):
9157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9159 
      return
9160 
    iprot.readStructBegin()
9161 
    while True:
9162 
      (fname, ftype, fid) = iprot.readFieldBegin()
9163 
      if ftype == TType.STOP:
9164 
        break
9165 
      if fid == 0:
9166 
        if ftype == TType.STRUCT:
9167 
          self.success = MasterAffiliate()
9168 
          self.success.read(iprot)
9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      elif fid == 1:
9172 
        if ftype == TType.STRUCT:
1996 vikas 9173 
          self.utx = UserAffiliateException()
1845 vikas 9174 
          self.utx.read(iprot)
9175 
        else:
9176 
          iprot.skip(ftype)
9177 
      else:
9178 
        iprot.skip(ftype)
9179 
      iprot.readFieldEnd()
9180 
    iprot.readStructEnd()
9181 
 
9182 
  def write(self, oprot):
9183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9185 
      return
9186 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9187 
    if self.success is not None:
1845 vikas 9188 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9189 
      self.success.write(oprot)
9190 
      oprot.writeFieldEnd()
3431 rajveer 9191 
    if self.utx is not None:
1845 vikas 9192 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9193 
      self.utx.write(oprot)
9194 
      oprot.writeFieldEnd()
9195 
    oprot.writeFieldStop()
9196 
    oprot.writeStructEnd()
9197 
 
3431 rajveer 9198 
  def validate(self):
9199 
    return
9200 
 
9201 
 
1845 vikas 9202 
  def __repr__(self):
9203 
    L = ['%s=%r' % (key, value)
9204 
      for key, value in self.__dict__.iteritems()]
9205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9206 
 
9207 
  def __eq__(self, other):
9208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9209 
 
9210 
  def __ne__(self, other):
9211 
    return not (self == other)
9212 
 
9213 
class createAffiliate_args:
9214 
  """
9215 
  Attributes:
9216 
   - name
9217 
   - url
9218 
   - masterAffiliateId
1859 vikas 9219 
   - addedOn
1845 vikas 9220 
  """
9221 
 
9222 
  thrift_spec = (
9223 
    None, # 0
9224 
    (1, TType.STRING, 'name', None, None, ), # 1
9225 
    (2, TType.STRING, 'url', None, None, ), # 2
9226 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9227 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9228 
  )
9229 
 
1859 vikas 9230 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9231 
    self.name = name
9232 
    self.url = url
9233 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9234 
    self.addedOn = addedOn
1845 vikas 9235 
 
9236 
  def read(self, iprot):
9237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9239 
      return
9240 
    iprot.readStructBegin()
9241 
    while True:
9242 
      (fname, ftype, fid) = iprot.readFieldBegin()
9243 
      if ftype == TType.STOP:
9244 
        break
9245 
      if fid == 1:
9246 
        if ftype == TType.STRING:
9247 
          self.name = iprot.readString();
9248 
        else:
9249 
          iprot.skip(ftype)
9250 
      elif fid == 2:
9251 
        if ftype == TType.STRING:
9252 
          self.url = iprot.readString();
9253 
        else:
9254 
          iprot.skip(ftype)
9255 
      elif fid == 3:
9256 
        if ftype == TType.I64:
9257 
          self.masterAffiliateId = iprot.readI64();
9258 
        else:
9259 
          iprot.skip(ftype)
1859 vikas 9260 
      elif fid == 4:
9261 
        if ftype == TType.I64:
9262 
          self.addedOn = iprot.readI64();
9263 
        else:
9264 
          iprot.skip(ftype)
1845 vikas 9265 
      else:
9266 
        iprot.skip(ftype)
9267 
      iprot.readFieldEnd()
9268 
    iprot.readStructEnd()
9269 
 
9270 
  def write(self, oprot):
9271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9273 
      return
9274 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9275 
    if self.name is not None:
1845 vikas 9276 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9277 
      oprot.writeString(self.name)
9278 
      oprot.writeFieldEnd()
3431 rajveer 9279 
    if self.url is not None:
1845 vikas 9280 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9281 
      oprot.writeString(self.url)
9282 
      oprot.writeFieldEnd()
3431 rajveer 9283 
    if self.masterAffiliateId is not None:
1845 vikas 9284 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9285 
      oprot.writeI64(self.masterAffiliateId)
9286 
      oprot.writeFieldEnd()
3431 rajveer 9287 
    if self.addedOn is not None:
1859 vikas 9288 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9289 
      oprot.writeI64(self.addedOn)
9290 
      oprot.writeFieldEnd()
1845 vikas 9291 
    oprot.writeFieldStop()
9292 
    oprot.writeStructEnd()
9293 
 
3431 rajveer 9294 
  def validate(self):
9295 
    return
9296 
 
9297 
 
1845 vikas 9298 
  def __repr__(self):
9299 
    L = ['%s=%r' % (key, value)
9300 
      for key, value in self.__dict__.iteritems()]
9301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9302 
 
9303 
  def __eq__(self, other):
9304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9305 
 
9306 
  def __ne__(self, other):
9307 
    return not (self == other)
9308 
 
9309 
class createAffiliate_result:
9310 
  """
9311 
  Attributes:
9312 
   - success
9313 
   - utx
9314 
  """
9315 
 
9316 
  thrift_spec = (
9317 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9318 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9319 
  )
9320 
 
9321 
  def __init__(self, success=None, utx=None,):
9322 
    self.success = success
9323 
    self.utx = utx
9324 
 
9325 
  def read(self, iprot):
9326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9328 
      return
9329 
    iprot.readStructBegin()
9330 
    while True:
9331 
      (fname, ftype, fid) = iprot.readFieldBegin()
9332 
      if ftype == TType.STOP:
9333 
        break
9334 
      if fid == 0:
9335 
        if ftype == TType.STRUCT:
9336 
          self.success = Affiliate()
9337 
          self.success.read(iprot)
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      elif fid == 1:
9341 
        if ftype == TType.STRUCT:
1996 vikas 9342 
          self.utx = UserAffiliateException()
1845 vikas 9343 
          self.utx.read(iprot)
9344 
        else:
9345 
          iprot.skip(ftype)
9346 
      else:
9347 
        iprot.skip(ftype)
9348 
      iprot.readFieldEnd()
9349 
    iprot.readStructEnd()
9350 
 
9351 
  def write(self, oprot):
9352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9354 
      return
9355 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9356 
    if self.success is not None:
1845 vikas 9357 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9358 
      self.success.write(oprot)
9359 
      oprot.writeFieldEnd()
3431 rajveer 9360 
    if self.utx is not None:
1845 vikas 9361 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9362 
      self.utx.write(oprot)
9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
3431 rajveer 9367 
  def validate(self):
9368 
    return
9369 
 
9370 
 
1845 vikas 9371 
  def __repr__(self):
9372 
    L = ['%s=%r' % (key, value)
9373 
      for key, value in self.__dict__.iteritems()]
9374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9375 
 
9376 
  def __eq__(self, other):
9377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9378 
 
9379 
  def __ne__(self, other):
9380 
    return not (self == other)
9381 
 
9382 
class getAffiliateById_args:
9383 
  """
9384 
  Attributes:
9385 
   - id
9386 
  """
9387 
 
9388 
  thrift_spec = (
9389 
    None, # 0
9390 
    (1, TType.I64, 'id', None, None, ), # 1
9391 
  )
9392 
 
9393 
  def __init__(self, id=None,):
9394 
    self.id = id
9395 
 
9396 
  def read(self, iprot):
9397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9399 
      return
9400 
    iprot.readStructBegin()
9401 
    while True:
9402 
      (fname, ftype, fid) = iprot.readFieldBegin()
9403 
      if ftype == TType.STOP:
9404 
        break
9405 
      if fid == 1:
9406 
        if ftype == TType.I64:
9407 
          self.id = iprot.readI64();
9408 
        else:
9409 
          iprot.skip(ftype)
9410 
      else:
9411 
        iprot.skip(ftype)
9412 
      iprot.readFieldEnd()
9413 
    iprot.readStructEnd()
9414 
 
9415 
  def write(self, oprot):
9416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9418 
      return
9419 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9420 
    if self.id is not None:
1845 vikas 9421 
      oprot.writeFieldBegin('id', TType.I64, 1)
9422 
      oprot.writeI64(self.id)
9423 
      oprot.writeFieldEnd()
9424 
    oprot.writeFieldStop()
9425 
    oprot.writeStructEnd()
9426 
 
3431 rajveer 9427 
  def validate(self):
9428 
    return
9429 
 
9430 
 
1845 vikas 9431 
  def __repr__(self):
9432 
    L = ['%s=%r' % (key, value)
9433 
      for key, value in self.__dict__.iteritems()]
9434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9435 
 
9436 
  def __eq__(self, other):
9437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9438 
 
9439 
  def __ne__(self, other):
9440 
    return not (self == other)
9441 
 
9442 
class getAffiliateById_result:
9443 
  """
9444 
  Attributes:
9445 
   - success
9446 
   - utx
9447 
  """
9448 
 
9449 
  thrift_spec = (
9450 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9451 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9452 
  )
9453 
 
9454 
  def __init__(self, success=None, utx=None,):
9455 
    self.success = success
9456 
    self.utx = utx
9457 
 
9458 
  def read(self, iprot):
9459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9461 
      return
9462 
    iprot.readStructBegin()
9463 
    while True:
9464 
      (fname, ftype, fid) = iprot.readFieldBegin()
9465 
      if ftype == TType.STOP:
9466 
        break
9467 
      if fid == 0:
9468 
        if ftype == TType.STRUCT:
9469 
          self.success = Affiliate()
9470 
          self.success.read(iprot)
9471 
        else:
9472 
          iprot.skip(ftype)
9473 
      elif fid == 1:
9474 
        if ftype == TType.STRUCT:
1996 vikas 9475 
          self.utx = UserAffiliateException()
1845 vikas 9476 
          self.utx.read(iprot)
9477 
        else:
9478 
          iprot.skip(ftype)
9479 
      else:
9480 
        iprot.skip(ftype)
9481 
      iprot.readFieldEnd()
9482 
    iprot.readStructEnd()
9483 
 
9484 
  def write(self, oprot):
9485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9487 
      return
9488 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9489 
    if self.success is not None:
1845 vikas 9490 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9491 
      self.success.write(oprot)
9492 
      oprot.writeFieldEnd()
3431 rajveer 9493 
    if self.utx is not None:
1845 vikas 9494 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9495 
      self.utx.write(oprot)
9496 
      oprot.writeFieldEnd()
9497 
    oprot.writeFieldStop()
9498 
    oprot.writeStructEnd()
9499 
 
3431 rajveer 9500 
  def validate(self):
9501 
    return
9502 
 
9503 
 
1845 vikas 9504 
  def __repr__(self):
9505 
    L = ['%s=%r' % (key, value)
9506 
      for key, value in self.__dict__.iteritems()]
9507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9508 
 
9509 
  def __eq__(self, other):
9510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9511 
 
9512 
  def __ne__(self, other):
9513 
    return not (self == other)
9514 
 
9515 
class getAffiliateByName_args:
9516 
  """
9517 
  Attributes:
9518 
   - name
9519 
  """
9520 
 
9521 
  thrift_spec = (
9522 
    None, # 0
9523 
    (1, TType.STRING, 'name', None, None, ), # 1
9524 
  )
9525 
 
9526 
  def __init__(self, name=None,):
9527 
    self.name = name
9528 
 
9529 
  def read(self, iprot):
9530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9532 
      return
9533 
    iprot.readStructBegin()
9534 
    while True:
9535 
      (fname, ftype, fid) = iprot.readFieldBegin()
9536 
      if ftype == TType.STOP:
9537 
        break
9538 
      if fid == 1:
9539 
        if ftype == TType.STRING:
9540 
          self.name = iprot.readString();
9541 
        else:
9542 
          iprot.skip(ftype)
9543 
      else:
9544 
        iprot.skip(ftype)
9545 
      iprot.readFieldEnd()
9546 
    iprot.readStructEnd()
9547 
 
9548 
  def write(self, oprot):
9549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9551 
      return
9552 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9553 
    if self.name is not None:
1845 vikas 9554 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9555 
      oprot.writeString(self.name)
9556 
      oprot.writeFieldEnd()
9557 
    oprot.writeFieldStop()
9558 
    oprot.writeStructEnd()
9559 
 
3431 rajveer 9560 
  def validate(self):
9561 
    return
9562 
 
9563 
 
1845 vikas 9564 
  def __repr__(self):
9565 
    L = ['%s=%r' % (key, value)
9566 
      for key, value in self.__dict__.iteritems()]
9567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9568 
 
9569 
  def __eq__(self, other):
9570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9571 
 
9572 
  def __ne__(self, other):
9573 
    return not (self == other)
9574 
 
9575 
class getAffiliateByName_result:
9576 
  """
9577 
  Attributes:
9578 
   - success
9579 
   - utx
9580 
  """
9581 
 
9582 
  thrift_spec = (
9583 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9584 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9585 
  )
9586 
 
9587 
  def __init__(self, success=None, utx=None,):
9588 
    self.success = success
9589 
    self.utx = utx
9590 
 
9591 
  def read(self, iprot):
9592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9594 
      return
9595 
    iprot.readStructBegin()
9596 
    while True:
9597 
      (fname, ftype, fid) = iprot.readFieldBegin()
9598 
      if ftype == TType.STOP:
9599 
        break
9600 
      if fid == 0:
9601 
        if ftype == TType.STRUCT:
9602 
          self.success = Affiliate()
9603 
          self.success.read(iprot)
9604 
        else:
9605 
          iprot.skip(ftype)
9606 
      elif fid == 1:
9607 
        if ftype == TType.STRUCT:
1996 vikas 9608 
          self.utx = UserAffiliateException()
1845 vikas 9609 
          self.utx.read(iprot)
9610 
        else:
9611 
          iprot.skip(ftype)
9612 
      else:
9613 
        iprot.skip(ftype)
9614 
      iprot.readFieldEnd()
9615 
    iprot.readStructEnd()
9616 
 
9617 
  def write(self, oprot):
9618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9620 
      return
9621 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9622 
    if self.success is not None:
1845 vikas 9623 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9624 
      self.success.write(oprot)
9625 
      oprot.writeFieldEnd()
3431 rajveer 9626 
    if self.utx is not None:
1845 vikas 9627 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9628 
      self.utx.write(oprot)
9629 
      oprot.writeFieldEnd()
9630 
    oprot.writeFieldStop()
9631 
    oprot.writeStructEnd()
9632 
 
3431 rajveer 9633 
  def validate(self):
9634 
    return
9635 
 
9636 
 
1845 vikas 9637 
  def __repr__(self):
9638 
    L = ['%s=%r' % (key, value)
9639 
      for key, value in self.__dict__.iteritems()]
9640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9641 
 
9642 
  def __eq__(self, other):
9643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9644 
 
9645 
  def __ne__(self, other):
9646 
    return not (self == other)
9647 
 
1996 vikas 9648 
class getTrackerById_args:
1845 vikas 9649 
  """
9650 
  Attributes:
9651 
   - id
9652 
  """
9653 
 
9654 
  thrift_spec = (
9655 
    None, # 0
9656 
    (1, TType.I64, 'id', None, None, ), # 1
9657 
  )
9658 
 
9659 
  def __init__(self, id=None,):
9660 
    self.id = id
9661 
 
9662 
  def read(self, iprot):
9663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9665 
      return
9666 
    iprot.readStructBegin()
9667 
    while True:
9668 
      (fname, ftype, fid) = iprot.readFieldBegin()
9669 
      if ftype == TType.STOP:
9670 
        break
9671 
      if fid == 1:
9672 
        if ftype == TType.I64:
9673 
          self.id = iprot.readI64();
9674 
        else:
9675 
          iprot.skip(ftype)
9676 
      else:
9677 
        iprot.skip(ftype)
9678 
      iprot.readFieldEnd()
9679 
    iprot.readStructEnd()
9680 
 
9681 
  def write(self, oprot):
9682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9684 
      return
1996 vikas 9685 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9686 
    if self.id is not None:
1845 vikas 9687 
      oprot.writeFieldBegin('id', TType.I64, 1)
9688 
      oprot.writeI64(self.id)
9689 
      oprot.writeFieldEnd()
9690 
    oprot.writeFieldStop()
9691 
    oprot.writeStructEnd()
9692 
 
3431 rajveer 9693 
  def validate(self):
9694 
    return
9695 
 
9696 
 
1845 vikas 9697 
  def __repr__(self):
9698 
    L = ['%s=%r' % (key, value)
9699 
      for key, value in self.__dict__.iteritems()]
9700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9701 
 
9702 
  def __eq__(self, other):
9703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9704 
 
9705 
  def __ne__(self, other):
9706 
    return not (self == other)
9707 
 
9708 
class getTrackerById_result:
9709 
  """
9710 
  Attributes:
9711 
   - success
9712 
   - utx
9713 
  """
9714 
 
9715 
  thrift_spec = (
9716 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9717 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9718 
  )
9719 
 
9720 
  def __init__(self, success=None, utx=None,):
9721 
    self.success = success
9722 
    self.utx = utx
9723 
 
9724 
  def read(self, iprot):
9725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9727 
      return
9728 
    iprot.readStructBegin()
9729 
    while True:
9730 
      (fname, ftype, fid) = iprot.readFieldBegin()
9731 
      if ftype == TType.STOP:
9732 
        break
9733 
      if fid == 0:
9734 
        if ftype == TType.STRUCT:
9735 
          self.success = Tracker()
9736 
          self.success.read(iprot)
9737 
        else:
9738 
          iprot.skip(ftype)
9739 
      elif fid == 1:
9740 
        if ftype == TType.STRUCT:
1996 vikas 9741 
          self.utx = UserAffiliateException()
1845 vikas 9742 
          self.utx.read(iprot)
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
9754 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9755 
    if self.success is not None:
1845 vikas 9756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9757 
      self.success.write(oprot)
9758 
      oprot.writeFieldEnd()
3431 rajveer 9759 
    if self.utx is not None:
1845 vikas 9760 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9761 
      self.utx.write(oprot)
9762 
      oprot.writeFieldEnd()
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
3431 rajveer 9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
1845 vikas 9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
1996 vikas 9781 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9782 
  """
9783 
  Attributes:
1996 vikas 9784 
   - id
1845 vikas 9785 
  """
9786 
 
9787 
  thrift_spec = (
9788 
    None, # 0
1996 vikas 9789 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9790 
  )
9791 
 
1996 vikas 9792 
  def __init__(self, id=None,):
9793 
    self.id = id
1845 vikas 9794 
 
9795 
  def read(self, iprot):
9796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9798 
      return
9799 
    iprot.readStructBegin()
9800 
    while True:
9801 
      (fname, ftype, fid) = iprot.readFieldBegin()
9802 
      if ftype == TType.STOP:
9803 
        break
9804 
      if fid == 1:
9805 
        if ftype == TType.I64:
1996 vikas 9806 
          self.id = iprot.readI64();
1845 vikas 9807 
        else:
9808 
          iprot.skip(ftype)
9809 
      else:
9810 
        iprot.skip(ftype)
9811 
      iprot.readFieldEnd()
9812 
    iprot.readStructEnd()
9813 
 
9814 
  def write(self, oprot):
9815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9817 
      return
1996 vikas 9818 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9819 
    if self.id is not None:
1996 vikas 9820 
      oprot.writeFieldBegin('id', TType.I64, 1)
9821 
      oprot.writeI64(self.id)
1845 vikas 9822 
      oprot.writeFieldEnd()
9823 
    oprot.writeFieldStop()
9824 
    oprot.writeStructEnd()
9825 
 
3431 rajveer 9826 
  def validate(self):
9827 
    return
9828 
 
9829 
 
1845 vikas 9830 
  def __repr__(self):
9831 
    L = ['%s=%r' % (key, value)
9832 
      for key, value in self.__dict__.iteritems()]
9833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9834 
 
9835 
  def __eq__(self, other):
9836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9837 
 
9838 
  def __ne__(self, other):
9839 
    return not (self == other)
9840 
 
1996 vikas 9841 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9842 
  """
9843 
  Attributes:
9844 
   - success
9845 
   - utx
9846 
  """
9847 
 
9848 
  thrift_spec = (
1996 vikas 9849 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9850 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9851 
  )
9852 
 
9853 
  def __init__(self, success=None, utx=None,):
9854 
    self.success = success
9855 
    self.utx = utx
9856 
 
9857 
  def read(self, iprot):
9858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9860 
      return
9861 
    iprot.readStructBegin()
9862 
    while True:
9863 
      (fname, ftype, fid) = iprot.readFieldBegin()
9864 
      if ftype == TType.STOP:
9865 
        break
9866 
      if fid == 0:
9867 
        if ftype == TType.LIST:
9868 
          self.success = []
11592 amit.gupta 9869 
          (_etype128, _size125) = iprot.readListBegin()
9870 
          for _i129 in xrange(_size125):
9871 
            _elem130 = Affiliate()
9872 
            _elem130.read(iprot)
9873 
            self.success.append(_elem130)
1845 vikas 9874 
          iprot.readListEnd()
9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      elif fid == 1:
9878 
        if ftype == TType.STRUCT:
1996 vikas 9879 
          self.utx = UserAffiliateException()
1845 vikas 9880 
          self.utx.read(iprot)
9881 
        else:
9882 
          iprot.skip(ftype)
9883 
      else:
9884 
        iprot.skip(ftype)
9885 
      iprot.readFieldEnd()
9886 
    iprot.readStructEnd()
9887 
 
9888 
  def write(self, oprot):
9889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9891 
      return
1996 vikas 9892 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9893 
    if self.success is not None:
1845 vikas 9894 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9895 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9896 
      for iter131 in self.success:
9897 
        iter131.write(oprot)
1845 vikas 9898 
      oprot.writeListEnd()
9899 
      oprot.writeFieldEnd()
3431 rajveer 9900 
    if self.utx is not None:
1845 vikas 9901 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9902 
      self.utx.write(oprot)
9903 
      oprot.writeFieldEnd()
9904 
    oprot.writeFieldStop()
9905 
    oprot.writeStructEnd()
9906 
 
3431 rajveer 9907 
  def validate(self):
9908 
    return
9909 
 
9910 
 
1845 vikas 9911 
  def __repr__(self):
9912 
    L = ['%s=%r' % (key, value)
9913 
      for key, value in self.__dict__.iteritems()]
9914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9915 
 
9916 
  def __eq__(self, other):
9917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9918 
 
9919 
  def __ne__(self, other):
9920 
    return not (self == other)
9921 
 
9922 
class addTrackLog_args:
9923 
  """
9924 
  Attributes:
1996 vikas 9925 
   - affiliateId
1845 vikas 9926 
   - userId
9927 
   - event
9928 
   - url
9929 
   - data
1859 vikas 9930 
   - addedOn
1845 vikas 9931 
  """
9932 
 
9933 
  thrift_spec = (
9934 
    None, # 0
1996 vikas 9935 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9936 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9937 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9938 
    (4, TType.STRING, 'url', None, None, ), # 4
9939 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9940 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9941 
  )
9942 
 
1996 vikas 9943 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9944 
    self.affiliateId = affiliateId
1845 vikas 9945 
    self.userId = userId
9946 
    self.event = event
9947 
    self.url = url
9948 
    self.data = data
1859 vikas 9949 
    self.addedOn = addedOn
1845 vikas 9950 
 
9951 
  def read(self, iprot):
9952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9954 
      return
9955 
    iprot.readStructBegin()
9956 
    while True:
9957 
      (fname, ftype, fid) = iprot.readFieldBegin()
9958 
      if ftype == TType.STOP:
9959 
        break
9960 
      if fid == 1:
9961 
        if ftype == TType.I64:
1996 vikas 9962 
          self.affiliateId = iprot.readI64();
1845 vikas 9963 
        else:
9964 
          iprot.skip(ftype)
9965 
      elif fid == 2:
9966 
        if ftype == TType.I64:
9967 
          self.userId = iprot.readI64();
9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      elif fid == 3:
3378 vikas 9971 
        if ftype == TType.I32:
9972 
          self.event = iprot.readI32();
1845 vikas 9973 
        else:
9974 
          iprot.skip(ftype)
9975 
      elif fid == 4:
9976 
        if ftype == TType.STRING:
9977 
          self.url = iprot.readString();
9978 
        else:
9979 
          iprot.skip(ftype)
9980 
      elif fid == 5:
9981 
        if ftype == TType.STRING:
9982 
          self.data = iprot.readString();
9983 
        else:
9984 
          iprot.skip(ftype)
1859 vikas 9985 
      elif fid == 6:
9986 
        if ftype == TType.I64:
9987 
          self.addedOn = iprot.readI64();
9988 
        else:
9989 
          iprot.skip(ftype)
1845 vikas 9990 
      else:
9991 
        iprot.skip(ftype)
9992 
      iprot.readFieldEnd()
9993 
    iprot.readStructEnd()
9994 
 
9995 
  def write(self, oprot):
9996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9998 
      return
9999 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 10000 
    if self.affiliateId is not None:
1996 vikas 10001 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10002 
      oprot.writeI64(self.affiliateId)
1845 vikas 10003 
      oprot.writeFieldEnd()
3431 rajveer 10004 
    if self.userId is not None:
1845 vikas 10005 
      oprot.writeFieldBegin('userId', TType.I64, 2)
10006 
      oprot.writeI64(self.userId)
10007 
      oprot.writeFieldEnd()
3431 rajveer 10008 
    if self.event is not None:
3378 vikas 10009 
      oprot.writeFieldBegin('event', TType.I32, 3)
10010 
      oprot.writeI32(self.event)
1845 vikas 10011 
      oprot.writeFieldEnd()
3431 rajveer 10012 
    if self.url is not None:
1845 vikas 10013 
      oprot.writeFieldBegin('url', TType.STRING, 4)
10014 
      oprot.writeString(self.url)
10015 
      oprot.writeFieldEnd()
3431 rajveer 10016 
    if self.data is not None:
1845 vikas 10017 
      oprot.writeFieldBegin('data', TType.STRING, 5)
10018 
      oprot.writeString(self.data)
10019 
      oprot.writeFieldEnd()
3431 rajveer 10020 
    if self.addedOn is not None:
1859 vikas 10021 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
10022 
      oprot.writeI64(self.addedOn)
10023 
      oprot.writeFieldEnd()
1845 vikas 10024 
    oprot.writeFieldStop()
10025 
    oprot.writeStructEnd()
10026 
 
3431 rajveer 10027 
  def validate(self):
10028 
    return
10029 
 
10030 
 
1845 vikas 10031 
  def __repr__(self):
10032 
    L = ['%s=%r' % (key, value)
10033 
      for key, value in self.__dict__.iteritems()]
10034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10035 
 
10036 
  def __eq__(self, other):
10037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10038 
 
10039 
  def __ne__(self, other):
10040 
    return not (self == other)
10041 
 
10042 
class addTrackLog_result:
10043 
  """
10044 
  Attributes:
10045 
   - success
10046 
   - utx
10047 
  """
10048 
 
10049 
  thrift_spec = (
10050 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10051 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10052 
  )
10053 
 
10054 
  def __init__(self, success=None, utx=None,):
10055 
    self.success = success
10056 
    self.utx = utx
10057 
 
10058 
  def read(self, iprot):
10059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10061 
      return
10062 
    iprot.readStructBegin()
10063 
    while True:
10064 
      (fname, ftype, fid) = iprot.readFieldBegin()
10065 
      if ftype == TType.STOP:
10066 
        break
10067 
      if fid == 0:
10068 
        if ftype == TType.I64:
10069 
          self.success = iprot.readI64();
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      elif fid == 1:
10073 
        if ftype == TType.STRUCT:
1996 vikas 10074 
          self.utx = UserAffiliateException()
1845 vikas 10075 
          self.utx.read(iprot)
10076 
        else:
10077 
          iprot.skip(ftype)
10078 
      else:
10079 
        iprot.skip(ftype)
10080 
      iprot.readFieldEnd()
10081 
    iprot.readStructEnd()
10082 
 
10083 
  def write(self, oprot):
10084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10086 
      return
10087 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10088 
    if self.success is not None:
1845 vikas 10089 
      oprot.writeFieldBegin('success', TType.I64, 0)
10090 
      oprot.writeI64(self.success)
10091 
      oprot.writeFieldEnd()
3431 rajveer 10092 
    if self.utx is not None:
1845 vikas 10093 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10094 
      self.utx.write(oprot)
10095 
      oprot.writeFieldEnd()
10096 
    oprot.writeFieldStop()
10097 
    oprot.writeStructEnd()
10098 
 
3431 rajveer 10099 
  def validate(self):
10100 
    return
10101 
 
10102 
 
1845 vikas 10103 
  def __repr__(self):
10104 
    L = ['%s=%r' % (key, value)
10105 
      for key, value in self.__dict__.iteritems()]
10106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10107 
 
10108 
  def __eq__(self, other):
10109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10110 
 
10111 
  def __ne__(self, other):
10112 
    return not (self == other)
10113 
 
10114 
class getTrackLogById_args:
10115 
  """
10116 
  Attributes:
10117 
   - id
10118 
  """
10119 
 
10120 
  thrift_spec = (
10121 
    None, # 0
10122 
    (1, TType.I64, 'id', None, None, ), # 1
10123 
  )
10124 
 
10125 
  def __init__(self, id=None,):
10126 
    self.id = id
10127 
 
10128 
  def read(self, iprot):
10129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10131 
      return
10132 
    iprot.readStructBegin()
10133 
    while True:
10134 
      (fname, ftype, fid) = iprot.readFieldBegin()
10135 
      if ftype == TType.STOP:
10136 
        break
10137 
      if fid == 1:
10138 
        if ftype == TType.I64:
10139 
          self.id = iprot.readI64();
10140 
        else:
10141 
          iprot.skip(ftype)
10142 
      else:
10143 
        iprot.skip(ftype)
10144 
      iprot.readFieldEnd()
10145 
    iprot.readStructEnd()
10146 
 
10147 
  def write(self, oprot):
10148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10150 
      return
10151 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10152 
    if self.id is not None:
1845 vikas 10153 
      oprot.writeFieldBegin('id', TType.I64, 1)
10154 
      oprot.writeI64(self.id)
10155 
      oprot.writeFieldEnd()
10156 
    oprot.writeFieldStop()
10157 
    oprot.writeStructEnd()
10158 
 
3431 rajveer 10159 
  def validate(self):
10160 
    return
10161 
 
10162 
 
1845 vikas 10163 
  def __repr__(self):
10164 
    L = ['%s=%r' % (key, value)
10165 
      for key, value in self.__dict__.iteritems()]
10166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10167 
 
10168 
  def __eq__(self, other):
10169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10170 
 
10171 
  def __ne__(self, other):
10172 
    return not (self == other)
10173 
 
10174 
class getTrackLogById_result:
10175 
  """
10176 
  Attributes:
10177 
   - success
10178 
   - utx
10179 
  """
10180 
 
10181 
  thrift_spec = (
10182 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10183 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10184 
  )
10185 
 
10186 
  def __init__(self, success=None, utx=None,):
10187 
    self.success = success
10188 
    self.utx = utx
10189 
 
10190 
  def read(self, iprot):
10191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10193 
      return
10194 
    iprot.readStructBegin()
10195 
    while True:
10196 
      (fname, ftype, fid) = iprot.readFieldBegin()
10197 
      if ftype == TType.STOP:
10198 
        break
10199 
      if fid == 0:
10200 
        if ftype == TType.STRUCT:
10201 
          self.success = TrackLog()
10202 
          self.success.read(iprot)
10203 
        else:
10204 
          iprot.skip(ftype)
10205 
      elif fid == 1:
10206 
        if ftype == TType.STRUCT:
1996 vikas 10207 
          self.utx = UserAffiliateException()
1845 vikas 10208 
          self.utx.read(iprot)
10209 
        else:
10210 
          iprot.skip(ftype)
10211 
      else:
10212 
        iprot.skip(ftype)
10213 
      iprot.readFieldEnd()
10214 
    iprot.readStructEnd()
10215 
 
10216 
  def write(self, oprot):
10217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10219 
      return
10220 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10221 
    if self.success is not None:
1845 vikas 10222 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10223 
      self.success.write(oprot)
10224 
      oprot.writeFieldEnd()
3431 rajveer 10225 
    if self.utx is not None:
1845 vikas 10226 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10227 
      self.utx.write(oprot)
10228 
      oprot.writeFieldEnd()
10229 
    oprot.writeFieldStop()
10230 
    oprot.writeStructEnd()
10231 
 
3431 rajveer 10232 
  def validate(self):
10233 
    return
10234 
 
10235 
 
1845 vikas 10236 
  def __repr__(self):
10237 
    L = ['%s=%r' % (key, value)
10238 
      for key, value in self.__dict__.iteritems()]
10239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10240 
 
10241 
  def __eq__(self, other):
10242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10243 
 
10244 
  def __ne__(self, other):
10245 
    return not (self == other)
10246 
 
1996 vikas 10247 
class getTrackLogsByAffiliate_args:
1845 vikas 10248 
  """
10249 
  Attributes:
1996 vikas 10250 
   - affiliateId
3293 vikas 10251 
   - startDate
10252 
   - endDate
1845 vikas 10253 
  """
10254 
 
10255 
  thrift_spec = (
10256 
    None, # 0
1996 vikas 10257 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10258 
    (2, TType.I64, 'startDate', None, None, ), # 2
10259 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10260 
  )
10261 
 
3293 vikas 10262 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10263 
    self.affiliateId = affiliateId
3293 vikas 10264 
    self.startDate = startDate
10265 
    self.endDate = endDate
1845 vikas 10266 
 
10267 
  def read(self, iprot):
10268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10270 
      return
10271 
    iprot.readStructBegin()
10272 
    while True:
10273 
      (fname, ftype, fid) = iprot.readFieldBegin()
10274 
      if ftype == TType.STOP:
10275 
        break
10276 
      if fid == 1:
10277 
        if ftype == TType.I64:
1996 vikas 10278 
          self.affiliateId = iprot.readI64();
1845 vikas 10279 
        else:
10280 
          iprot.skip(ftype)
3293 vikas 10281 
      elif fid == 2:
10282 
        if ftype == TType.I64:
10283 
          self.startDate = iprot.readI64();
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      elif fid == 3:
10287 
        if ftype == TType.I64:
10288 
          self.endDate = iprot.readI64();
10289 
        else:
10290 
          iprot.skip(ftype)
1845 vikas 10291 
      else:
10292 
        iprot.skip(ftype)
10293 
      iprot.readFieldEnd()
10294 
    iprot.readStructEnd()
10295 
 
10296 
  def write(self, oprot):
10297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10299 
      return
1996 vikas 10300 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10301 
    if self.affiliateId is not None:
1996 vikas 10302 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10303 
      oprot.writeI64(self.affiliateId)
1845 vikas 10304 
      oprot.writeFieldEnd()
3431 rajveer 10305 
    if self.startDate is not None:
3293 vikas 10306 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10307 
      oprot.writeI64(self.startDate)
10308 
      oprot.writeFieldEnd()
3431 rajveer 10309 
    if self.endDate is not None:
3293 vikas 10310 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10311 
      oprot.writeI64(self.endDate)
10312 
      oprot.writeFieldEnd()
1845 vikas 10313 
    oprot.writeFieldStop()
10314 
    oprot.writeStructEnd()
10315 
 
3431 rajveer 10316 
  def validate(self):
10317 
    return
10318 
 
10319 
 
1845 vikas 10320 
  def __repr__(self):
10321 
    L = ['%s=%r' % (key, value)
10322 
      for key, value in self.__dict__.iteritems()]
10323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10324 
 
10325 
  def __eq__(self, other):
10326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10327 
 
10328 
  def __ne__(self, other):
10329 
    return not (self == other)
10330 
 
1996 vikas 10331 
class getTrackLogsByAffiliate_result:
1845 vikas 10332 
  """
10333 
  Attributes:
10334 
   - success
10335 
   - utx
10336 
  """
10337 
 
10338 
  thrift_spec = (
10339 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10340 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10341 
  )
10342 
 
10343 
  def __init__(self, success=None, utx=None,):
10344 
    self.success = success
10345 
    self.utx = utx
10346 
 
10347 
  def read(self, iprot):
10348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10350 
      return
10351 
    iprot.readStructBegin()
10352 
    while True:
10353 
      (fname, ftype, fid) = iprot.readFieldBegin()
10354 
      if ftype == TType.STOP:
10355 
        break
10356 
      if fid == 0:
10357 
        if ftype == TType.LIST:
10358 
          self.success = []
11592 amit.gupta 10359 
          (_etype135, _size132) = iprot.readListBegin()
10360 
          for _i136 in xrange(_size132):
10361 
            _elem137 = TrackLog()
10362 
            _elem137.read(iprot)
10363 
            self.success.append(_elem137)
1845 vikas 10364 
          iprot.readListEnd()
10365 
        else:
10366 
          iprot.skip(ftype)
10367 
      elif fid == 1:
10368 
        if ftype == TType.STRUCT:
1996 vikas 10369 
          self.utx = UserAffiliateException()
1845 vikas 10370 
          self.utx.read(iprot)
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
1996 vikas 10382 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10383 
    if self.success is not None:
1845 vikas 10384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10386 
      for iter138 in self.success:
10387 
        iter138.write(oprot)
1845 vikas 10388 
      oprot.writeListEnd()
10389 
      oprot.writeFieldEnd()
3431 rajveer 10390 
    if self.utx is not None:
1845 vikas 10391 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10392 
      self.utx.write(oprot)
10393 
      oprot.writeFieldEnd()
10394 
    oprot.writeFieldStop()
10395 
    oprot.writeStructEnd()
10396 
 
3431 rajveer 10397 
  def validate(self):
10398 
    return
10399 
 
10400 
 
1845 vikas 10401 
  def __repr__(self):
10402 
    L = ['%s=%r' % (key, value)
10403 
      for key, value in self.__dict__.iteritems()]
10404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10405 
 
10406 
  def __eq__(self, other):
10407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10408 
 
10409 
  def __ne__(self, other):
10410 
    return not (self == other)
10411 
 
10412 
class getTrackLogsByUser_args:
10413 
  """
10414 
  Attributes:
10415 
   - userId
10416 
  """
10417 
 
10418 
  thrift_spec = (
10419 
    None, # 0
10420 
    (1, TType.I64, 'userId', None, None, ), # 1
10421 
  )
10422 
 
10423 
  def __init__(self, userId=None,):
10424 
    self.userId = userId
10425 
 
10426 
  def read(self, iprot):
10427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10429 
      return
10430 
    iprot.readStructBegin()
10431 
    while True:
10432 
      (fname, ftype, fid) = iprot.readFieldBegin()
10433 
      if ftype == TType.STOP:
10434 
        break
10435 
      if fid == 1:
10436 
        if ftype == TType.I64:
10437 
          self.userId = iprot.readI64();
10438 
        else:
10439 
          iprot.skip(ftype)
10440 
      else:
10441 
        iprot.skip(ftype)
10442 
      iprot.readFieldEnd()
10443 
    iprot.readStructEnd()
10444 
 
10445 
  def write(self, oprot):
10446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10448 
      return
10449 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10450 
    if self.userId is not None:
1845 vikas 10451 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10452 
      oprot.writeI64(self.userId)
10453 
      oprot.writeFieldEnd()
10454 
    oprot.writeFieldStop()
10455 
    oprot.writeStructEnd()
10456 
 
3431 rajveer 10457 
  def validate(self):
10458 
    return
10459 
 
10460 
 
1845 vikas 10461 
  def __repr__(self):
10462 
    L = ['%s=%r' % (key, value)
10463 
      for key, value in self.__dict__.iteritems()]
10464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10465 
 
10466 
  def __eq__(self, other):
10467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10468 
 
10469 
  def __ne__(self, other):
10470 
    return not (self == other)
10471 
 
10472 
class getTrackLogsByUser_result:
10473 
  """
10474 
  Attributes:
10475 
   - success
10476 
   - utx
10477 
  """
10478 
 
10479 
  thrift_spec = (
10480 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10481 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10482 
  )
10483 
 
10484 
  def __init__(self, success=None, utx=None,):
10485 
    self.success = success
10486 
    self.utx = utx
10487 
 
10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
10497 
      if fid == 0:
10498 
        if ftype == TType.LIST:
10499 
          self.success = []
11592 amit.gupta 10500 
          (_etype142, _size139) = iprot.readListBegin()
10501 
          for _i143 in xrange(_size139):
10502 
            _elem144 = TrackLog()
10503 
            _elem144.read(iprot)
10504 
            self.success.append(_elem144)
1845 vikas 10505 
          iprot.readListEnd()
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      elif fid == 1:
10509 
        if ftype == TType.STRUCT:
1996 vikas 10510 
          self.utx = UserAffiliateException()
1845 vikas 10511 
          self.utx.read(iprot)
10512 
        else:
10513 
          iprot.skip(ftype)
10514 
      else:
10515 
        iprot.skip(ftype)
10516 
      iprot.readFieldEnd()
10517 
    iprot.readStructEnd()
10518 
 
10519 
  def write(self, oprot):
10520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10522 
      return
10523 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10524 
    if self.success is not None:
1845 vikas 10525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10526 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10527 
      for iter145 in self.success:
10528 
        iter145.write(oprot)
1845 vikas 10529 
      oprot.writeListEnd()
10530 
      oprot.writeFieldEnd()
3431 rajveer 10531 
    if self.utx is not None:
1845 vikas 10532 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10533 
      self.utx.write(oprot)
10534 
      oprot.writeFieldEnd()
10535 
    oprot.writeFieldStop()
10536 
    oprot.writeStructEnd()
10537 
 
3431 rajveer 10538 
  def validate(self):
10539 
    return
10540 
 
10541 
 
1845 vikas 10542 
  def __repr__(self):
10543 
    L = ['%s=%r' % (key, value)
10544 
      for key, value in self.__dict__.iteritems()]
10545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10546 
 
10547 
  def __eq__(self, other):
10548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10549 
 
10550 
  def __ne__(self, other):
10551 
    return not (self == other)
10552 
 
10553 
class getTrackLogs_args:
10554 
  """
10555 
  Attributes:
10556 
   - userId
10557 
   - event
10558 
   - url
10559 
  """
10560 
 
10561 
  thrift_spec = (
10562 
    None, # 0
1996 vikas 10563 
    (1, TType.I64, 'userId', None, None, ), # 1
10564 
    (2, TType.STRING, 'event', None, None, ), # 2
10565 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10566 
  )
10567 
 
1996 vikas 10568 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10569 
    self.userId = userId
10570 
    self.event = event
10571 
    self.url = url
10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
10582 
      if fid == 1:
10583 
        if ftype == TType.I64:
1996 vikas 10584 
          self.userId = iprot.readI64();
1845 vikas 10585 
        else:
10586 
          iprot.skip(ftype)
10587 
      elif fid == 2:
10588 
        if ftype == TType.STRING:
10589 
          self.event = iprot.readString();
10590 
        else:
10591 
          iprot.skip(ftype)
1996 vikas 10592 
      elif fid == 3:
1845 vikas 10593 
        if ftype == TType.STRING:
10594 
          self.url = iprot.readString();
10595 
        else:
10596 
          iprot.skip(ftype)
10597 
      else:
10598 
        iprot.skip(ftype)
10599 
      iprot.readFieldEnd()
10600 
    iprot.readStructEnd()
10601 
 
10602 
  def write(self, oprot):
10603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10605 
      return
10606 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10607 
    if self.userId is not None:
1996 vikas 10608 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10609 
      oprot.writeI64(self.userId)
10610 
      oprot.writeFieldEnd()
3431 rajveer 10611 
    if self.event is not None:
1996 vikas 10612 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10613 
      oprot.writeString(self.event)
10614 
      oprot.writeFieldEnd()
3431 rajveer 10615 
    if self.url is not None:
1996 vikas 10616 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10617 
      oprot.writeString(self.url)
10618 
      oprot.writeFieldEnd()
10619 
    oprot.writeFieldStop()
10620 
    oprot.writeStructEnd()
10621 
 
3431 rajveer 10622 
  def validate(self):
10623 
    return
10624 
 
10625 
 
1845 vikas 10626 
  def __repr__(self):
10627 
    L = ['%s=%r' % (key, value)
10628 
      for key, value in self.__dict__.iteritems()]
10629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10630 
 
10631 
  def __eq__(self, other):
10632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10633 
 
10634 
  def __ne__(self, other):
10635 
    return not (self == other)
10636 
 
10637 
class getTrackLogs_result:
10638 
  """
10639 
  Attributes:
10640 
   - success
10641 
   - utx
10642 
  """
10643 
 
10644 
  thrift_spec = (
10645 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10646 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10647 
  )
10648 
 
10649 
  def __init__(self, success=None, utx=None,):
10650 
    self.success = success
10651 
    self.utx = utx
10652 
 
10653 
  def read(self, iprot):
10654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10656 
      return
10657 
    iprot.readStructBegin()
10658 
    while True:
10659 
      (fname, ftype, fid) = iprot.readFieldBegin()
10660 
      if ftype == TType.STOP:
10661 
        break
10662 
      if fid == 0:
10663 
        if ftype == TType.LIST:
10664 
          self.success = []
11592 amit.gupta 10665 
          (_etype149, _size146) = iprot.readListBegin()
10666 
          for _i150 in xrange(_size146):
10667 
            _elem151 = TrackLog()
10668 
            _elem151.read(iprot)
10669 
            self.success.append(_elem151)
1845 vikas 10670 
          iprot.readListEnd()
10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      elif fid == 1:
10674 
        if ftype == TType.STRUCT:
1996 vikas 10675 
          self.utx = UserAffiliateException()
1845 vikas 10676 
          self.utx.read(iprot)
10677 
        else:
10678 
          iprot.skip(ftype)
10679 
      else:
10680 
        iprot.skip(ftype)
10681 
      iprot.readFieldEnd()
10682 
    iprot.readStructEnd()
10683 
 
10684 
  def write(self, oprot):
10685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10687 
      return
10688 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10689 
    if self.success is not None:
1845 vikas 10690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10692 
      for iter152 in self.success:
10693 
        iter152.write(oprot)
1845 vikas 10694 
      oprot.writeListEnd()
10695 
      oprot.writeFieldEnd()
3431 rajveer 10696 
    if self.utx is not None:
1845 vikas 10697 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10698 
      self.utx.write(oprot)
10699 
      oprot.writeFieldEnd()
10700 
    oprot.writeFieldStop()
10701 
    oprot.writeStructEnd()
10702 
 
3431 rajveer 10703 
  def validate(self):
10704 
    return
10705 
 
10706 
 
1845 vikas 10707 
  def __repr__(self):
10708 
    L = ['%s=%r' % (key, value)
10709 
      for key, value in self.__dict__.iteritems()]
10710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10711 
 
10712 
  def __eq__(self, other):
10713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10714 
 
10715 
  def __ne__(self, other):
10716 
    return not (self == other)
10717 
 
559 chandransh 10718 
class getCurrentCart_args:
94 ashish 10719 
  """
10720 
  Attributes:
559 chandransh 10721 
   - userId
10722 
  """
10723 
 
10724 
  thrift_spec = (
10725 
    None, # 0
10726 
    (1, TType.I64, 'userId', None, None, ), # 1
10727 
  )
10728 
 
10729 
  def __init__(self, userId=None,):
10730 
    self.userId = userId
10731 
 
10732 
  def read(self, iprot):
10733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10735 
      return
10736 
    iprot.readStructBegin()
10737 
    while True:
10738 
      (fname, ftype, fid) = iprot.readFieldBegin()
10739 
      if ftype == TType.STOP:
10740 
        break
10741 
      if fid == 1:
10742 
        if ftype == TType.I64:
10743 
          self.userId = iprot.readI64();
10744 
        else:
10745 
          iprot.skip(ftype)
10746 
      else:
10747 
        iprot.skip(ftype)
10748 
      iprot.readFieldEnd()
10749 
    iprot.readStructEnd()
10750 
 
10751 
  def write(self, oprot):
10752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10754 
      return
10755 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10756 
    if self.userId is not None:
559 chandransh 10757 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10758 
      oprot.writeI64(self.userId)
10759 
      oprot.writeFieldEnd()
10760 
    oprot.writeFieldStop()
10761 
    oprot.writeStructEnd()
10762 
 
3431 rajveer 10763 
  def validate(self):
10764 
    return
10765 
 
10766 
 
559 chandransh 10767 
  def __repr__(self):
10768 
    L = ['%s=%r' % (key, value)
10769 
      for key, value in self.__dict__.iteritems()]
10770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10771 
 
10772 
  def __eq__(self, other):
10773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10774 
 
10775 
  def __ne__(self, other):
10776 
    return not (self == other)
10777 
 
10778 
class getCurrentCart_result:
10779 
  """
10780 
  Attributes:
94 ashish 10781 
   - success
559 chandransh 10782 
   - scx
94 ashish 10783 
  """
10784 
 
10785 
  thrift_spec = (
559 chandransh 10786 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10787 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10788 
  )
10789 
 
559 chandransh 10790 
  def __init__(self, success=None, scx=None,):
94 ashish 10791 
    self.success = success
559 chandransh 10792 
    self.scx = scx
94 ashish 10793 
 
10794 
  def read(self, iprot):
10795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10797 
      return
10798 
    iprot.readStructBegin()
10799 
    while True:
10800 
      (fname, ftype, fid) = iprot.readFieldBegin()
10801 
      if ftype == TType.STOP:
10802 
        break
10803 
      if fid == 0:
559 chandransh 10804 
        if ftype == TType.STRUCT:
10805 
          self.success = Cart()
10806 
          self.success.read(iprot)
94 ashish 10807 
        else:
10808 
          iprot.skip(ftype)
10809 
      elif fid == 1:
10810 
        if ftype == TType.STRUCT:
559 chandransh 10811 
          self.scx = ShoppingCartException()
10812 
          self.scx.read(iprot)
94 ashish 10813 
        else:
10814 
          iprot.skip(ftype)
10815 
      else:
10816 
        iprot.skip(ftype)
10817 
      iprot.readFieldEnd()
10818 
    iprot.readStructEnd()
10819 
 
10820 
  def write(self, oprot):
10821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10823 
      return
559 chandransh 10824 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10825 
    if self.success is not None:
559 chandransh 10826 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10827 
      self.success.write(oprot)
94 ashish 10828 
      oprot.writeFieldEnd()
3431 rajveer 10829 
    if self.scx is not None:
559 chandransh 10830 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10831 
      self.scx.write(oprot)
94 ashish 10832 
      oprot.writeFieldEnd()
10833 
    oprot.writeFieldStop()
10834 
    oprot.writeStructEnd()
10835 
 
3431 rajveer 10836 
  def validate(self):
10837 
    return
10838 
 
10839 
 
94 ashish 10840 
  def __repr__(self):
10841 
    L = ['%s=%r' % (key, value)
10842 
      for key, value in self.__dict__.iteritems()]
10843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10844 
 
10845 
  def __eq__(self, other):
10846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10847 
 
10848 
  def __ne__(self, other):
10849 
    return not (self == other)
10850 
 
559 chandransh 10851 
class getCart_args:
504 rajveer 10852 
  """
10853 
  Attributes:
559 chandransh 10854 
   - cartId
504 rajveer 10855 
  """
10856 
 
10857 
  thrift_spec = (
10858 
    None, # 0
559 chandransh 10859 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10860 
  )
10861 
 
559 chandransh 10862 
  def __init__(self, cartId=None,):
10863 
    self.cartId = cartId
504 rajveer 10864 
 
10865 
  def read(self, iprot):
10866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10868 
      return
10869 
    iprot.readStructBegin()
10870 
    while True:
10871 
      (fname, ftype, fid) = iprot.readFieldBegin()
10872 
      if ftype == TType.STOP:
10873 
        break
10874 
      if fid == 1:
10875 
        if ftype == TType.I64:
559 chandransh 10876 
          self.cartId = iprot.readI64();
504 rajveer 10877 
        else:
10878 
          iprot.skip(ftype)
10879 
      else:
10880 
        iprot.skip(ftype)
10881 
      iprot.readFieldEnd()
10882 
    iprot.readStructEnd()
10883 
 
10884 
  def write(self, oprot):
10885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10887 
      return
559 chandransh 10888 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10889 
    if self.cartId is not None:
559 chandransh 10890 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10891 
      oprot.writeI64(self.cartId)
504 rajveer 10892 
      oprot.writeFieldEnd()
10893 
    oprot.writeFieldStop()
10894 
    oprot.writeStructEnd()
10895 
 
3431 rajveer 10896 
  def validate(self):
10897 
    return
10898 
 
10899 
 
504 rajveer 10900 
  def __repr__(self):
10901 
    L = ['%s=%r' % (key, value)
10902 
      for key, value in self.__dict__.iteritems()]
10903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10904 
 
10905 
  def __eq__(self, other):
10906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10907 
 
10908 
  def __ne__(self, other):
10909 
    return not (self == other)
10910 
 
559 chandransh 10911 
class getCart_result:
504 rajveer 10912 
  """
10913 
  Attributes:
10914 
   - success
559 chandransh 10915 
   - scx
504 rajveer 10916 
  """
10917 
 
10918 
  thrift_spec = (
559 chandransh 10919 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10920 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10921 
  )
10922 
 
559 chandransh 10923 
  def __init__(self, success=None, scx=None,):
504 rajveer 10924 
    self.success = success
559 chandransh 10925 
    self.scx = scx
504 rajveer 10926 
 
10927 
  def read(self, iprot):
10928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10930 
      return
10931 
    iprot.readStructBegin()
10932 
    while True:
10933 
      (fname, ftype, fid) = iprot.readFieldBegin()
10934 
      if ftype == TType.STOP:
10935 
        break
10936 
      if fid == 0:
559 chandransh 10937 
        if ftype == TType.STRUCT:
10938 
          self.success = Cart()
10939 
          self.success.read(iprot)
504 rajveer 10940 
        else:
10941 
          iprot.skip(ftype)
10942 
      elif fid == 1:
10943 
        if ftype == TType.STRUCT:
559 chandransh 10944 
          self.scx = ShoppingCartException()
10945 
          self.scx.read(iprot)
504 rajveer 10946 
        else:
10947 
          iprot.skip(ftype)
10948 
      else:
10949 
        iprot.skip(ftype)
10950 
      iprot.readFieldEnd()
10951 
    iprot.readStructEnd()
10952 
 
10953 
  def write(self, oprot):
10954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10956 
      return
559 chandransh 10957 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10958 
    if self.success is not None:
559 chandransh 10959 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10960 
      self.success.write(oprot)
504 rajveer 10961 
      oprot.writeFieldEnd()
3431 rajveer 10962 
    if self.scx is not None:
559 chandransh 10963 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10964 
      self.scx.write(oprot)
504 rajveer 10965 
      oprot.writeFieldEnd()
10966 
    oprot.writeFieldStop()
10967 
    oprot.writeStructEnd()
10968 
 
3431 rajveer 10969 
  def validate(self):
10970 
    return
10971 
 
10972 
 
504 rajveer 10973 
  def __repr__(self):
10974 
    L = ['%s=%r' % (key, value)
10975 
      for key, value in self.__dict__.iteritems()]
10976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10977 
 
10978 
  def __eq__(self, other):
10979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10980 
 
10981 
  def __ne__(self, other):
10982 
    return not (self == other)
10983 
 
559 chandransh 10984 
class getCartsByTime_args:
10985 
  """
10986 
  Attributes:
10987 
   - from_time
10988 
   - to_time
10989 
   - status
10990 
  """
10991 
 
10992 
  thrift_spec = (
10993 
    None, # 0
10994 
    (1, TType.I64, 'from_time', None, None, ), # 1
10995 
    (2, TType.I64, 'to_time', None, None, ), # 2
10996 
    (3, TType.I32, 'status', None, None, ), # 3
10997 
  )
10998 
 
10999 
  def __init__(self, from_time=None, to_time=None, status=None,):
11000 
    self.from_time = from_time
11001 
    self.to_time = to_time
11002 
    self.status = status
11003 
 
11004 
  def read(self, iprot):
11005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11007 
      return
11008 
    iprot.readStructBegin()
11009 
    while True:
11010 
      (fname, ftype, fid) = iprot.readFieldBegin()
11011 
      if ftype == TType.STOP:
11012 
        break
11013 
      if fid == 1:
94 ashish 11014 
        if ftype == TType.I64:
559 chandransh 11015 
          self.from_time = iprot.readI64();
94 ashish 11016 
        else:
11017 
          iprot.skip(ftype)
122 ashish 11018 
      elif fid == 2:
559 chandransh 11019 
        if ftype == TType.I64:
11020 
          self.to_time = iprot.readI64();
122 ashish 11021 
        else:
11022 
          iprot.skip(ftype)
559 chandransh 11023 
      elif fid == 3:
11024 
        if ftype == TType.I32:
11025 
          self.status = iprot.readI32();
11026 
        else:
11027 
          iprot.skip(ftype)
94 ashish 11028 
      else:
11029 
        iprot.skip(ftype)
11030 
      iprot.readFieldEnd()
11031 
    iprot.readStructEnd()
11032 
 
11033 
  def write(self, oprot):
11034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11036 
      return
559 chandransh 11037 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 11038 
    if self.from_time is not None:
559 chandransh 11039 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
11040 
      oprot.writeI64(self.from_time)
94 ashish 11041 
      oprot.writeFieldEnd()
3431 rajveer 11042 
    if self.to_time is not None:
559 chandransh 11043 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
11044 
      oprot.writeI64(self.to_time)
122 ashish 11045 
      oprot.writeFieldEnd()
3431 rajveer 11046 
    if self.status is not None:
559 chandransh 11047 
      oprot.writeFieldBegin('status', TType.I32, 3)
11048 
      oprot.writeI32(self.status)
11049 
      oprot.writeFieldEnd()
94 ashish 11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
3431 rajveer 11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
94 ashish 11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
559 chandransh 11068 
class getCartsByTime_result:
94 ashish 11069 
  """
11070 
  Attributes:
11071 
   - success
559 chandransh 11072 
   - scx
94 ashish 11073 
  """
11074 
 
11075 
  thrift_spec = (
559 chandransh 11076 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11077 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11078 
  )
11079 
 
559 chandransh 11080 
  def __init__(self, success=None, scx=None,):
94 ashish 11081 
    self.success = success
559 chandransh 11082 
    self.scx = scx
94 ashish 11083 
 
11084 
  def read(self, iprot):
11085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11087 
      return
11088 
    iprot.readStructBegin()
11089 
    while True:
11090 
      (fname, ftype, fid) = iprot.readFieldBegin()
11091 
      if ftype == TType.STOP:
11092 
        break
11093 
      if fid == 0:
559 chandransh 11094 
        if ftype == TType.LIST:
11095 
          self.success = []
11592 amit.gupta 11096 
          (_etype156, _size153) = iprot.readListBegin()
11097 
          for _i157 in xrange(_size153):
11098 
            _elem158 = Cart()
11099 
            _elem158.read(iprot)
11100 
            self.success.append(_elem158)
559 chandransh 11101 
          iprot.readListEnd()
94 ashish 11102 
        else:
11103 
          iprot.skip(ftype)
11104 
      elif fid == 1:
11105 
        if ftype == TType.STRUCT:
559 chandransh 11106 
          self.scx = ShoppingCartException()
11107 
          self.scx.read(iprot)
94 ashish 11108 
        else:
11109 
          iprot.skip(ftype)
11110 
      else:
11111 
        iprot.skip(ftype)
11112 
      iprot.readFieldEnd()
11113 
    iprot.readStructEnd()
11114 
 
11115 
  def write(self, oprot):
11116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11118 
      return
559 chandransh 11119 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11120 
    if self.success is not None:
559 chandransh 11121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11122 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11123 
      for iter159 in self.success:
11124 
        iter159.write(oprot)
559 chandransh 11125 
      oprot.writeListEnd()
94 ashish 11126 
      oprot.writeFieldEnd()
3431 rajveer 11127 
    if self.scx is not None:
559 chandransh 11128 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11129 
      self.scx.write(oprot)
94 ashish 11130 
      oprot.writeFieldEnd()
11131 
    oprot.writeFieldStop()
11132 
    oprot.writeStructEnd()
11133 
 
3431 rajveer 11134 
  def validate(self):
11135 
    return
11136 
 
11137 
 
94 ashish 11138 
  def __repr__(self):
11139 
    L = ['%s=%r' % (key, value)
11140 
      for key, value in self.__dict__.iteritems()]
11141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11142 
 
11143 
  def __eq__(self, other):
11144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11145 
 
11146 
  def __ne__(self, other):
11147 
    return not (self == other)
11148 
 
559 chandransh 11149 
class addItemToCart_args:
11150 
  """
11151 
  Attributes:
11152 
   - cartId
11153 
   - itemId
11154 
   - quantity
3557 rajveer 11155 
   - sourceId
559 chandransh 11156 
  """
11157 
 
11158 
  thrift_spec = (
11159 
    None, # 0
11160 
    (1, TType.I64, 'cartId', None, None, ), # 1
11161 
    (2, TType.I64, 'itemId', None, None, ), # 2
11162 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11163 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11164 
  )
11165 
 
3557 rajveer 11166 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11167 
    self.cartId = cartId
11168 
    self.itemId = itemId
11169 
    self.quantity = quantity
3557 rajveer 11170 
    self.sourceId = sourceId
559 chandransh 11171 
 
11172 
  def read(self, iprot):
11173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11175 
      return
11176 
    iprot.readStructBegin()
11177 
    while True:
11178 
      (fname, ftype, fid) = iprot.readFieldBegin()
11179 
      if ftype == TType.STOP:
11180 
        break
11181 
      if fid == 1:
11182 
        if ftype == TType.I64:
11183 
          self.cartId = iprot.readI64();
11184 
        else:
11185 
          iprot.skip(ftype)
11186 
      elif fid == 2:
11187 
        if ftype == TType.I64:
11188 
          self.itemId = iprot.readI64();
11189 
        else:
11190 
          iprot.skip(ftype)
11191 
      elif fid == 3:
11192 
        if ftype == TType.I64:
11193 
          self.quantity = iprot.readI64();
11194 
        else:
11195 
          iprot.skip(ftype)
3557 rajveer 11196 
      elif fid == 4:
11197 
        if ftype == TType.I64:
11198 
          self.sourceId = iprot.readI64();
11199 
        else:
11200 
          iprot.skip(ftype)
559 chandransh 11201 
      else:
11202 
        iprot.skip(ftype)
11203 
      iprot.readFieldEnd()
11204 
    iprot.readStructEnd()
11205 
 
11206 
  def write(self, oprot):
11207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11209 
      return
11210 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11211 
    if self.cartId is not None:
559 chandransh 11212 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11213 
      oprot.writeI64(self.cartId)
11214 
      oprot.writeFieldEnd()
3431 rajveer 11215 
    if self.itemId is not None:
559 chandransh 11216 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11217 
      oprot.writeI64(self.itemId)
11218 
      oprot.writeFieldEnd()
3431 rajveer 11219 
    if self.quantity is not None:
559 chandransh 11220 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11221 
      oprot.writeI64(self.quantity)
11222 
      oprot.writeFieldEnd()
3557 rajveer 11223 
    if self.sourceId is not None:
11224 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11225 
      oprot.writeI64(self.sourceId)
11226 
      oprot.writeFieldEnd()
559 chandransh 11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
3431 rajveer 11230 
  def validate(self):
11231 
    return
11232 
 
11233 
 
559 chandransh 11234 
  def __repr__(self):
11235 
    L = ['%s=%r' % (key, value)
11236 
      for key, value in self.__dict__.iteritems()]
11237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11238 
 
11239 
  def __eq__(self, other):
11240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11241 
 
11242 
  def __ne__(self, other):
11243 
    return not (self == other)
11244 
 
11245 
class addItemToCart_result:
11246 
  """
11247 
  Attributes:
2035 rajveer 11248 
   - success
559 chandransh 11249 
   - scx
11250 
  """
11251 
 
11252 
  thrift_spec = (
2035 rajveer 11253 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11254 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11255 
  )
11256 
 
2035 rajveer 11257 
  def __init__(self, success=None, scx=None,):
11258 
    self.success = success
559 chandransh 11259 
    self.scx = scx
11260 
 
11261 
  def read(self, iprot):
11262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11264 
      return
11265 
    iprot.readStructBegin()
11266 
    while True:
11267 
      (fname, ftype, fid) = iprot.readFieldBegin()
11268 
      if ftype == TType.STOP:
11269 
        break
2035 rajveer 11270 
      if fid == 0:
11271 
        if ftype == TType.STRING:
11272 
          self.success = iprot.readString();
11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      elif fid == 1:
559 chandransh 11276 
        if ftype == TType.STRUCT:
11277 
          self.scx = ShoppingCartException()
11278 
          self.scx.read(iprot)
11279 
        else:
11280 
          iprot.skip(ftype)
11281 
      else:
11282 
        iprot.skip(ftype)
11283 
      iprot.readFieldEnd()
11284 
    iprot.readStructEnd()
11285 
 
11286 
  def write(self, oprot):
11287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11289 
      return
11290 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11291 
    if self.success is not None:
2035 rajveer 11292 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11293 
      oprot.writeString(self.success)
11294 
      oprot.writeFieldEnd()
3431 rajveer 11295 
    if self.scx is not None:
559 chandransh 11296 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11297 
      self.scx.write(oprot)
11298 
      oprot.writeFieldEnd()
11299 
    oprot.writeFieldStop()
11300 
    oprot.writeStructEnd()
11301 
 
3431 rajveer 11302 
  def validate(self):
11303 
    return
11304 
 
11305 
 
559 chandransh 11306 
  def __repr__(self):
11307 
    L = ['%s=%r' % (key, value)
11308 
      for key, value in self.__dict__.iteritems()]
11309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11310 
 
11311 
  def __eq__(self, other):
11312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11313 
 
11314 
  def __ne__(self, other):
11315 
    return not (self == other)
11316 
 
11317 
class deleteItemFromCart_args:
11318 
  """
11319 
  Attributes:
11320 
   - cartId
11321 
   - itemId
11322 
  """
11323 
 
11324 
  thrift_spec = (
11325 
    None, # 0
11326 
    (1, TType.I64, 'cartId', None, None, ), # 1
11327 
    (2, TType.I64, 'itemId', None, None, ), # 2
11328 
  )
11329 
 
11330 
  def __init__(self, cartId=None, itemId=None,):
11331 
    self.cartId = cartId
11332 
    self.itemId = itemId
11333 
 
11334 
  def read(self, iprot):
11335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11337 
      return
11338 
    iprot.readStructBegin()
11339 
    while True:
11340 
      (fname, ftype, fid) = iprot.readFieldBegin()
11341 
      if ftype == TType.STOP:
11342 
        break
11343 
      if fid == 1:
11344 
        if ftype == TType.I64:
11345 
          self.cartId = iprot.readI64();
11346 
        else:
11347 
          iprot.skip(ftype)
11348 
      elif fid == 2:
11349 
        if ftype == TType.I64:
11350 
          self.itemId = iprot.readI64();
11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      else:
11354 
        iprot.skip(ftype)
11355 
      iprot.readFieldEnd()
11356 
    iprot.readStructEnd()
11357 
 
11358 
  def write(self, oprot):
11359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11361 
      return
11362 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11363 
    if self.cartId is not None:
559 chandransh 11364 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11365 
      oprot.writeI64(self.cartId)
11366 
      oprot.writeFieldEnd()
3431 rajveer 11367 
    if self.itemId is not None:
559 chandransh 11368 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11369 
      oprot.writeI64(self.itemId)
11370 
      oprot.writeFieldEnd()
11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
3431 rajveer 11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
559 chandransh 11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
11389 
class deleteItemFromCart_result:
11390 
  """
11391 
  Attributes:
11392 
   - scx
11393 
  """
11394 
 
11395 
  thrift_spec = (
11396 
    None, # 0
11397 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11398 
  )
11399 
 
11400 
  def __init__(self, scx=None,):
11401 
    self.scx = scx
11402 
 
11403 
  def read(self, iprot):
11404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11406 
      return
11407 
    iprot.readStructBegin()
11408 
    while True:
11409 
      (fname, ftype, fid) = iprot.readFieldBegin()
11410 
      if ftype == TType.STOP:
11411 
        break
11412 
      if fid == 1:
11413 
        if ftype == TType.STRUCT:
11414 
          self.scx = ShoppingCartException()
11415 
          self.scx.read(iprot)
11416 
        else:
11417 
          iprot.skip(ftype)
11418 
      else:
11419 
        iprot.skip(ftype)
11420 
      iprot.readFieldEnd()
11421 
    iprot.readStructEnd()
11422 
 
11423 
  def write(self, oprot):
11424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11426 
      return
11427 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11428 
    if self.scx is not None:
559 chandransh 11429 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11430 
      self.scx.write(oprot)
11431 
      oprot.writeFieldEnd()
11432 
    oprot.writeFieldStop()
11433 
    oprot.writeStructEnd()
11434 
 
3431 rajveer 11435 
  def validate(self):
11436 
    return
11437 
 
11438 
 
559 chandransh 11439 
  def __repr__(self):
11440 
    L = ['%s=%r' % (key, value)
11441 
      for key, value in self.__dict__.iteritems()]
11442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11443 
 
11444 
  def __eq__(self, other):
11445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11446 
 
11447 
  def __ne__(self, other):
11448 
    return not (self == other)
11449 
 
11450 
class addAddressToCart_args:
11451 
  """
11452 
  Attributes:
11453 
   - cartId
11454 
   - addressId
11455 
  """
11456 
 
11457 
  thrift_spec = (
11458 
    None, # 0
11459 
    (1, TType.I64, 'cartId', None, None, ), # 1
11460 
    (2, TType.I64, 'addressId', None, None, ), # 2
11461 
  )
11462 
 
11463 
  def __init__(self, cartId=None, addressId=None,):
11464 
    self.cartId = cartId
11465 
    self.addressId = addressId
11466 
 
11467 
  def read(self, iprot):
11468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11470 
      return
11471 
    iprot.readStructBegin()
11472 
    while True:
11473 
      (fname, ftype, fid) = iprot.readFieldBegin()
11474 
      if ftype == TType.STOP:
11475 
        break
11476 
      if fid == 1:
11477 
        if ftype == TType.I64:
11478 
          self.cartId = iprot.readI64();
11479 
        else:
11480 
          iprot.skip(ftype)
11481 
      elif fid == 2:
11482 
        if ftype == TType.I64:
11483 
          self.addressId = iprot.readI64();
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      else:
11487 
        iprot.skip(ftype)
11488 
      iprot.readFieldEnd()
11489 
    iprot.readStructEnd()
11490 
 
11491 
  def write(self, oprot):
11492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11494 
      return
11495 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11496 
    if self.cartId is not None:
559 chandransh 11497 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11498 
      oprot.writeI64(self.cartId)
11499 
      oprot.writeFieldEnd()
3431 rajveer 11500 
    if self.addressId is not None:
559 chandransh 11501 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11502 
      oprot.writeI64(self.addressId)
11503 
      oprot.writeFieldEnd()
11504 
    oprot.writeFieldStop()
11505 
    oprot.writeStructEnd()
11506 
 
3431 rajveer 11507 
  def validate(self):
11508 
    return
11509 
 
11510 
 
559 chandransh 11511 
  def __repr__(self):
11512 
    L = ['%s=%r' % (key, value)
11513 
      for key, value in self.__dict__.iteritems()]
11514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11515 
 
11516 
  def __eq__(self, other):
11517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11518 
 
11519 
  def __ne__(self, other):
11520 
    return not (self == other)
11521 
 
11522 
class addAddressToCart_result:
575 chandransh 11523 
  """
11524 
  Attributes:
11525 
   - scx
11526 
  """
559 chandransh 11527 
 
11528 
  thrift_spec = (
575 chandransh 11529 
    None, # 0
11530 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11531 
  )
11532 
 
575 chandransh 11533 
  def __init__(self, scx=None,):
11534 
    self.scx = scx
11535 
 
559 chandransh 11536 
  def read(self, iprot):
11537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11539 
      return
11540 
    iprot.readStructBegin()
11541 
    while True:
11542 
      (fname, ftype, fid) = iprot.readFieldBegin()
11543 
      if ftype == TType.STOP:
11544 
        break
575 chandransh 11545 
      if fid == 1:
11546 
        if ftype == TType.STRUCT:
11547 
          self.scx = ShoppingCartException()
11548 
          self.scx.read(iprot)
11549 
        else:
11550 
          iprot.skip(ftype)
559 chandransh 11551 
      else:
11552 
        iprot.skip(ftype)
11553 
      iprot.readFieldEnd()
11554 
    iprot.readStructEnd()
11555 
 
11556 
  def write(self, oprot):
11557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11559 
      return
11560 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11561 
    if self.scx is not None:
575 chandransh 11562 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11563 
      self.scx.write(oprot)
11564 
      oprot.writeFieldEnd()
559 chandransh 11565 
    oprot.writeFieldStop()
11566 
    oprot.writeStructEnd()
11567 
 
3431 rajveer 11568 
  def validate(self):
11569 
    return
11570 
 
11571 
 
559 chandransh 11572 
  def __repr__(self):
11573 
    L = ['%s=%r' % (key, value)
11574 
      for key, value in self.__dict__.iteritems()]
11575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11576 
 
11577 
  def __eq__(self, other):
11578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11579 
 
11580 
  def __ne__(self, other):
11581 
    return not (self == other)
11582 
 
5553 rajveer 11583 
class addStoreToCart_args:
11584 
  """
11585 
  Attributes:
11586 
   - cartId
11587 
   - storeId
11588 
  """
11589 
 
11590 
  thrift_spec = (
11591 
    None, # 0
11592 
    (1, TType.I64, 'cartId', None, None, ), # 1
11593 
    (2, TType.I64, 'storeId', None, None, ), # 2
11594 
  )
11595 
 
11596 
  def __init__(self, cartId=None, storeId=None,):
11597 
    self.cartId = cartId
11598 
    self.storeId = storeId
11599 
 
11600 
  def read(self, iprot):
11601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11603 
      return
11604 
    iprot.readStructBegin()
11605 
    while True:
11606 
      (fname, ftype, fid) = iprot.readFieldBegin()
11607 
      if ftype == TType.STOP:
11608 
        break
11609 
      if fid == 1:
11610 
        if ftype == TType.I64:
11611 
          self.cartId = iprot.readI64();
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      elif fid == 2:
11615 
        if ftype == TType.I64:
11616 
          self.storeId = iprot.readI64();
11617 
        else:
11618 
          iprot.skip(ftype)
11619 
      else:
11620 
        iprot.skip(ftype)
11621 
      iprot.readFieldEnd()
11622 
    iprot.readStructEnd()
11623 
 
11624 
  def write(self, oprot):
11625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11627 
      return
11628 
    oprot.writeStructBegin('addStoreToCart_args')
11629 
    if self.cartId is not None:
11630 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11631 
      oprot.writeI64(self.cartId)
11632 
      oprot.writeFieldEnd()
11633 
    if self.storeId is not None:
11634 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11635 
      oprot.writeI64(self.storeId)
11636 
      oprot.writeFieldEnd()
11637 
    oprot.writeFieldStop()
11638 
    oprot.writeStructEnd()
11639 
 
11640 
  def validate(self):
11641 
    return
11642 
 
11643 
 
11644 
  def __repr__(self):
11645 
    L = ['%s=%r' % (key, value)
11646 
      for key, value in self.__dict__.iteritems()]
11647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11648 
 
11649 
  def __eq__(self, other):
11650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11651 
 
11652 
  def __ne__(self, other):
11653 
    return not (self == other)
11654 
 
11655 
class addStoreToCart_result:
11656 
  """
11657 
  Attributes:
11658 
   - scx
11659 
  """
11660 
 
11661 
  thrift_spec = (
11662 
    None, # 0
11663 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11664 
  )
11665 
 
11666 
  def __init__(self, scx=None,):
11667 
    self.scx = scx
11668 
 
11669 
  def read(self, iprot):
11670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11672 
      return
11673 
    iprot.readStructBegin()
11674 
    while True:
11675 
      (fname, ftype, fid) = iprot.readFieldBegin()
11676 
      if ftype == TType.STOP:
11677 
        break
11678 
      if fid == 1:
11679 
        if ftype == TType.STRUCT:
11680 
          self.scx = ShoppingCartException()
11681 
          self.scx.read(iprot)
11682 
        else:
11683 
          iprot.skip(ftype)
11684 
      else:
11685 
        iprot.skip(ftype)
11686 
      iprot.readFieldEnd()
11687 
    iprot.readStructEnd()
11688 
 
11689 
  def write(self, oprot):
11690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11692 
      return
11693 
    oprot.writeStructBegin('addStoreToCart_result')
11694 
    if self.scx is not None:
11695 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11696 
      self.scx.write(oprot)
11697 
      oprot.writeFieldEnd()
11698 
    oprot.writeFieldStop()
11699 
    oprot.writeStructEnd()
11700 
 
11701 
  def validate(self):
11702 
    return
11703 
 
11704 
 
11705 
  def __repr__(self):
11706 
    L = ['%s=%r' % (key, value)
11707 
      for key, value in self.__dict__.iteritems()]
11708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11709 
 
11710 
  def __eq__(self, other):
11711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11712 
 
11713 
  def __ne__(self, other):
11714 
    return not (self == other)
11715 
 
1976 varun.gupt 11716 
class applyCouponToCart_args:
11717 
  """
11718 
  Attributes:
6922 anupam.sin 11719 
   - cart
1976 varun.gupt 11720 
   - couponCode
11721 
  """
11722 
 
11723 
  thrift_spec = (
11724 
    None, # 0
6922 anupam.sin 11725 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11726 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11727 
  )
11728 
 
6922 anupam.sin 11729 
  def __init__(self, cart=None, couponCode=None,):
11730 
    self.cart = cart
1976 varun.gupt 11731 
    self.couponCode = couponCode
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 1:
6922 anupam.sin 11743 
        if ftype == TType.STRUCT:
11744 
          self.cart = Cart()
11745 
          self.cart.read(iprot)
1976 varun.gupt 11746 
        else:
11747 
          iprot.skip(ftype)
11748 
      elif fid == 2:
11749 
        if ftype == TType.STRING:
11750 
          self.couponCode = iprot.readString();
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      else:
11754 
        iprot.skip(ftype)
11755 
      iprot.readFieldEnd()
11756 
    iprot.readStructEnd()
11757 
 
11758 
  def write(self, oprot):
11759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11761 
      return
11762 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11763 
    if self.cart is not None:
11764 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11765 
      self.cart.write(oprot)
1976 varun.gupt 11766 
      oprot.writeFieldEnd()
3431 rajveer 11767 
    if self.couponCode is not None:
1976 varun.gupt 11768 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11769 
      oprot.writeString(self.couponCode)
11770 
      oprot.writeFieldEnd()
11771 
    oprot.writeFieldStop()
11772 
    oprot.writeStructEnd()
11773 
 
3431 rajveer 11774 
  def validate(self):
11775 
    return
11776 
 
11777 
 
1976 varun.gupt 11778 
  def __repr__(self):
11779 
    L = ['%s=%r' % (key, value)
11780 
      for key, value in self.__dict__.iteritems()]
11781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11782 
 
11783 
  def __eq__(self, other):
11784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11785 
 
11786 
  def __ne__(self, other):
11787 
    return not (self == other)
11788 
 
11789 
class applyCouponToCart_result:
11790 
  """
11791 
  Attributes:
11792 
   - scx
11793 
  """
11794 
 
11795 
  thrift_spec = (
11796 
    None, # 0
11797 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11798 
  )
11799 
 
11800 
  def __init__(self, scx=None,):
11801 
    self.scx = scx
11802 
 
11803 
  def read(self, iprot):
11804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11806 
      return
11807 
    iprot.readStructBegin()
11808 
    while True:
11809 
      (fname, ftype, fid) = iprot.readFieldBegin()
11810 
      if ftype == TType.STOP:
11811 
        break
11812 
      if fid == 1:
11813 
        if ftype == TType.STRUCT:
11814 
          self.scx = ShoppingCartException()
11815 
          self.scx.read(iprot)
11816 
        else:
11817 
          iprot.skip(ftype)
11818 
      else:
11819 
        iprot.skip(ftype)
11820 
      iprot.readFieldEnd()
11821 
    iprot.readStructEnd()
11822 
 
11823 
  def write(self, oprot):
11824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11826 
      return
11827 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11828 
    if self.scx is not None:
1976 varun.gupt 11829 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11830 
      self.scx.write(oprot)
11831 
      oprot.writeFieldEnd()
11832 
    oprot.writeFieldStop()
11833 
    oprot.writeStructEnd()
11834 
 
3431 rajveer 11835 
  def validate(self):
11836 
    return
11837 
 
11838 
 
1976 varun.gupt 11839 
  def __repr__(self):
11840 
    L = ['%s=%r' % (key, value)
11841 
      for key, value in self.__dict__.iteritems()]
11842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11843 
 
11844 
  def __eq__(self, other):
11845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11846 
 
11847 
  def __ne__(self, other):
11848 
    return not (self == other)
11849 
 
11850 
class removeCoupon_args:
11851 
  """
11852 
  Attributes:
11853 
   - cartId
11854 
  """
11855 
 
11856 
  thrift_spec = (
11857 
    None, # 0
11858 
    (1, TType.I64, 'cartId', None, None, ), # 1
11859 
  )
11860 
 
11861 
  def __init__(self, cartId=None,):
11862 
    self.cartId = cartId
11863 
 
11864 
  def read(self, iprot):
11865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11867 
      return
11868 
    iprot.readStructBegin()
11869 
    while True:
11870 
      (fname, ftype, fid) = iprot.readFieldBegin()
11871 
      if ftype == TType.STOP:
11872 
        break
11873 
      if fid == 1:
11874 
        if ftype == TType.I64:
11875 
          self.cartId = iprot.readI64();
11876 
        else:
11877 
          iprot.skip(ftype)
11878 
      else:
11879 
        iprot.skip(ftype)
11880 
      iprot.readFieldEnd()
11881 
    iprot.readStructEnd()
11882 
 
11883 
  def write(self, oprot):
11884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11886 
      return
11887 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11888 
    if self.cartId is not None:
1976 varun.gupt 11889 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11890 
      oprot.writeI64(self.cartId)
11891 
      oprot.writeFieldEnd()
11892 
    oprot.writeFieldStop()
11893 
    oprot.writeStructEnd()
11894 
 
3431 rajveer 11895 
  def validate(self):
11896 
    return
11897 
 
11898 
 
1976 varun.gupt 11899 
  def __repr__(self):
11900 
    L = ['%s=%r' % (key, value)
11901 
      for key, value in self.__dict__.iteritems()]
11902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11903 
 
11904 
  def __eq__(self, other):
11905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11906 
 
11907 
  def __ne__(self, other):
11908 
    return not (self == other)
11909 
 
11910 
class removeCoupon_result:
11911 
  """
11912 
  Attributes:
11913 
   - scx
11914 
  """
11915 
 
11916 
  thrift_spec = (
11917 
    None, # 0
11918 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11919 
  )
11920 
 
11921 
  def __init__(self, scx=None,):
11922 
    self.scx = scx
11923 
 
11924 
  def read(self, iprot):
11925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11927 
      return
11928 
    iprot.readStructBegin()
11929 
    while True:
11930 
      (fname, ftype, fid) = iprot.readFieldBegin()
11931 
      if ftype == TType.STOP:
11932 
        break
11933 
      if fid == 1:
11934 
        if ftype == TType.STRUCT:
11935 
          self.scx = ShoppingCartException()
11936 
          self.scx.read(iprot)
11937 
        else:
11938 
          iprot.skip(ftype)
11939 
      else:
11940 
        iprot.skip(ftype)
11941 
      iprot.readFieldEnd()
11942 
    iprot.readStructEnd()
11943 
 
11944 
  def write(self, oprot):
11945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11947 
      return
11948 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11949 
    if self.scx is not None:
1976 varun.gupt 11950 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11951 
      self.scx.write(oprot)
11952 
      oprot.writeFieldEnd()
11953 
    oprot.writeFieldStop()
11954 
    oprot.writeStructEnd()
11955 
 
3431 rajveer 11956 
  def validate(self):
11957 
    return
11958 
 
11959 
 
1976 varun.gupt 11960 
  def __repr__(self):
11961 
    L = ['%s=%r' % (key, value)
11962 
      for key, value in self.__dict__.iteritems()]
11963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11964 
 
11965 
  def __eq__(self, other):
11966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11967 
 
11968 
  def __ne__(self, other):
11969 
    return not (self == other)
11970 
 
3554 varun.gupt 11971 
class deleteDiscountsFromCart_args:
11972 
  """
11973 
  Attributes:
11974 
   - cartId
11975 
  """
11976 
 
11977 
  thrift_spec = (
11978 
    None, # 0
11979 
    (1, TType.I64, 'cartId', None, None, ), # 1
11980 
  )
11981 
 
11982 
  def __init__(self, cartId=None,):
11983 
    self.cartId = cartId
11984 
 
11985 
  def read(self, iprot):
11986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11988 
      return
11989 
    iprot.readStructBegin()
11990 
    while True:
11991 
      (fname, ftype, fid) = iprot.readFieldBegin()
11992 
      if ftype == TType.STOP:
11993 
        break
11994 
      if fid == 1:
11995 
        if ftype == TType.I64:
11996 
          self.cartId = iprot.readI64();
11997 
        else:
11998 
          iprot.skip(ftype)
11999 
      else:
12000 
        iprot.skip(ftype)
12001 
      iprot.readFieldEnd()
12002 
    iprot.readStructEnd()
12003 
 
12004 
  def write(self, oprot):
12005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12007 
      return
12008 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
12009 
    if self.cartId is not None:
12010 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12011 
      oprot.writeI64(self.cartId)
12012 
      oprot.writeFieldEnd()
12013 
    oprot.writeFieldStop()
12014 
    oprot.writeStructEnd()
12015 
 
12016 
  def validate(self):
12017 
    return
12018 
 
12019 
 
12020 
  def __repr__(self):
12021 
    L = ['%s=%r' % (key, value)
12022 
      for key, value in self.__dict__.iteritems()]
12023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12024 
 
12025 
  def __eq__(self, other):
12026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12027 
 
12028 
  def __ne__(self, other):
12029 
    return not (self == other)
12030 
 
12031 
class deleteDiscountsFromCart_result:
12032 
  """
12033 
  Attributes:
12034 
   - scx
12035 
  """
12036 
 
12037 
  thrift_spec = (
12038 
    None, # 0
12039 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12040 
  )
12041 
 
12042 
  def __init__(self, scx=None,):
12043 
    self.scx = scx
12044 
 
12045 
  def read(self, iprot):
12046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12048 
      return
12049 
    iprot.readStructBegin()
12050 
    while True:
12051 
      (fname, ftype, fid) = iprot.readFieldBegin()
12052 
      if ftype == TType.STOP:
12053 
        break
12054 
      if fid == 1:
12055 
        if ftype == TType.STRUCT:
12056 
          self.scx = ShoppingCartException()
12057 
          self.scx.read(iprot)
12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
12069 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12070 
    if self.scx is not None:
12071 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12072 
      self.scx.write(oprot)
12073 
      oprot.writeFieldEnd()
12074 
    oprot.writeFieldStop()
12075 
    oprot.writeStructEnd()
12076 
 
12077 
  def validate(self):
12078 
    return
12079 
 
12080 
 
12081 
  def __repr__(self):
12082 
    L = ['%s=%r' % (key, value)
12083 
      for key, value in self.__dict__.iteritems()]
12084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12085 
 
12086 
  def __eq__(self, other):
12087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12088 
 
12089 
  def __ne__(self, other):
12090 
    return not (self == other)
12091 
 
12092 
class saveDiscounts_args:
12093 
  """
12094 
  Attributes:
12095 
   - discounts
12096 
  """
12097 
 
12098 
  thrift_spec = (
12099 
    None, # 0
12100 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12101 
  )
12102 
 
12103 
  def __init__(self, discounts=None,):
12104 
    self.discounts = discounts
12105 
 
12106 
  def read(self, iprot):
12107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12109 
      return
12110 
    iprot.readStructBegin()
12111 
    while True:
12112 
      (fname, ftype, fid) = iprot.readFieldBegin()
12113 
      if ftype == TType.STOP:
12114 
        break
12115 
      if fid == 1:
12116 
        if ftype == TType.LIST:
12117 
          self.discounts = []
11592 amit.gupta 12118 
          (_etype163, _size160) = iprot.readListBegin()
12119 
          for _i164 in xrange(_size160):
12120 
            _elem165 = Discount()
12121 
            _elem165.read(iprot)
12122 
            self.discounts.append(_elem165)
3554 varun.gupt 12123 
          iprot.readListEnd()
12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      else:
12127 
        iprot.skip(ftype)
12128 
      iprot.readFieldEnd()
12129 
    iprot.readStructEnd()
12130 
 
12131 
  def write(self, oprot):
12132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12134 
      return
12135 
    oprot.writeStructBegin('saveDiscounts_args')
12136 
    if self.discounts is not None:
12137 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12138 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12139 
      for iter166 in self.discounts:
12140 
        iter166.write(oprot)
3554 varun.gupt 12141 
      oprot.writeListEnd()
12142 
      oprot.writeFieldEnd()
12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
12161 
class saveDiscounts_result:
12162 
  """
12163 
  Attributes:
12164 
   - scx
12165 
  """
12166 
 
12167 
  thrift_spec = (
12168 
    None, # 0
12169 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12170 
  )
12171 
 
12172 
  def __init__(self, scx=None,):
12173 
    self.scx = scx
12174 
 
12175 
  def read(self, iprot):
12176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12178 
      return
12179 
    iprot.readStructBegin()
12180 
    while True:
12181 
      (fname, ftype, fid) = iprot.readFieldBegin()
12182 
      if ftype == TType.STOP:
12183 
        break
12184 
      if fid == 1:
12185 
        if ftype == TType.STRUCT:
12186 
          self.scx = ShoppingCartException()
12187 
          self.scx.read(iprot)
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      else:
12191 
        iprot.skip(ftype)
12192 
      iprot.readFieldEnd()
12193 
    iprot.readStructEnd()
12194 
 
12195 
  def write(self, oprot):
12196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12198 
      return
12199 
    oprot.writeStructBegin('saveDiscounts_result')
12200 
    if self.scx is not None:
12201 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12202 
      self.scx.write(oprot)
12203 
      oprot.writeFieldEnd()
12204 
    oprot.writeFieldStop()
12205 
    oprot.writeStructEnd()
12206 
 
12207 
  def validate(self):
12208 
    return
12209 
 
12210 
 
12211 
  def __repr__(self):
12212 
    L = ['%s=%r' % (key, value)
12213 
      for key, value in self.__dict__.iteritems()]
12214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12215 
 
12216 
  def __eq__(self, other):
12217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12218 
 
12219 
  def __ne__(self, other):
12220 
    return not (self == other)
12221 
 
690 chandransh 12222 
class createOrders_args:
559 chandransh 12223 
  """
12224 
  Attributes:
12225 
   - cartId
2815 vikas 12226 
   - sessionSource
12227 
   - sessionStartTime
3858 vikas 12228 
   - firstSource
12229 
   - firstSourceTime
5326 rajveer 12230 
   - userId
6389 rajveer 12231 
   - schemeId
11526 amit.gupta 12232 
   - orderSource
559 chandransh 12233 
  """
12234 
 
12235 
  thrift_spec = (
12236 
    None, # 0
12237 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12238 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12239 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12240 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12241 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12242 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12243 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12244 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12245 
  )
12246 
 
11526 amit.gupta 12247 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12248 
    self.cartId = cartId
2815 vikas 12249 
    self.sessionSource = sessionSource
12250 
    self.sessionStartTime = sessionStartTime
3858 vikas 12251 
    self.firstSource = firstSource
12252 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12253 
    self.userId = userId
6389 rajveer 12254 
    self.schemeId = schemeId
11526 amit.gupta 12255 
    self.orderSource = orderSource
559 chandransh 12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 1:
12267 
        if ftype == TType.I64:
12268 
          self.cartId = iprot.readI64();
12269 
        else:
12270 
          iprot.skip(ftype)
2815 vikas 12271 
      elif fid == 2:
12272 
        if ftype == TType.STRING:
12273 
          self.sessionSource = iprot.readString();
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      elif fid == 3:
12277 
        if ftype == TType.I64:
12278 
          self.sessionStartTime = iprot.readI64();
12279 
        else:
12280 
          iprot.skip(ftype)
3858 vikas 12281 
      elif fid == 4:
12282 
        if ftype == TType.STRING:
12283 
          self.firstSource = iprot.readString();
12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      elif fid == 5:
12287 
        if ftype == TType.I64:
12288 
          self.firstSourceTime = iprot.readI64();
12289 
        else:
12290 
          iprot.skip(ftype)
5326 rajveer 12291 
      elif fid == 6:
12292 
        if ftype == TType.I64:
12293 
          self.userId = iprot.readI64();
12294 
        else:
12295 
          iprot.skip(ftype)
6389 rajveer 12296 
      elif fid == 7:
12297 
        if ftype == TType.I64:
12298 
          self.schemeId = iprot.readI64();
12299 
        else:
12300 
          iprot.skip(ftype)
11526 amit.gupta 12301 
      elif fid == 8:
12302 
        if ftype == TType.I64:
12303 
          self.orderSource = iprot.readI64();
12304 
        else:
12305 
          iprot.skip(ftype)
559 chandransh 12306 
      else:
12307 
        iprot.skip(ftype)
12308 
      iprot.readFieldEnd()
12309 
    iprot.readStructEnd()
12310 
 
12311 
  def write(self, oprot):
12312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12314 
      return
690 chandransh 12315 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12316 
    if self.cartId is not None:
559 chandransh 12317 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12318 
      oprot.writeI64(self.cartId)
12319 
      oprot.writeFieldEnd()
3431 rajveer 12320 
    if self.sessionSource is not None:
2815 vikas 12321 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12322 
      oprot.writeString(self.sessionSource)
12323 
      oprot.writeFieldEnd()
3431 rajveer 12324 
    if self.sessionStartTime is not None:
2815 vikas 12325 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12326 
      oprot.writeI64(self.sessionStartTime)
12327 
      oprot.writeFieldEnd()
3858 vikas 12328 
    if self.firstSource is not None:
12329 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12330 
      oprot.writeString(self.firstSource)
12331 
      oprot.writeFieldEnd()
12332 
    if self.firstSourceTime is not None:
12333 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12334 
      oprot.writeI64(self.firstSourceTime)
12335 
      oprot.writeFieldEnd()
5326 rajveer 12336 
    if self.userId is not None:
12337 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12338 
      oprot.writeI64(self.userId)
12339 
      oprot.writeFieldEnd()
6389 rajveer 12340 
    if self.schemeId is not None:
12341 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12342 
      oprot.writeI64(self.schemeId)
12343 
      oprot.writeFieldEnd()
11526 amit.gupta 12344 
    if self.orderSource is not None:
12345 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12346 
      oprot.writeI64(self.orderSource)
12347 
      oprot.writeFieldEnd()
559 chandransh 12348 
    oprot.writeFieldStop()
12349 
    oprot.writeStructEnd()
12350 
 
3431 rajveer 12351 
  def validate(self):
12352 
    return
12353 
 
12354 
 
559 chandransh 12355 
  def __repr__(self):
12356 
    L = ['%s=%r' % (key, value)
12357 
      for key, value in self.__dict__.iteritems()]
12358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12359 
 
12360 
  def __eq__(self, other):
12361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12362 
 
12363 
  def __ne__(self, other):
12364 
    return not (self == other)
12365 
 
690 chandransh 12366 
class createOrders_result:
559 chandransh 12367 
  """
12368 
  Attributes:
94 ashish 12369 
   - success
559 chandransh 12370 
   - scx
94 ashish 12371 
  """
12372 
 
12373 
  thrift_spec = (
575 chandransh 12374 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12375 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12376 
  )
12377 
 
559 chandransh 12378 
  def __init__(self, success=None, scx=None,):
94 ashish 12379 
    self.success = success
559 chandransh 12380 
    self.scx = scx
94 ashish 12381 
 
12382 
  def read(self, iprot):
12383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12385 
      return
12386 
    iprot.readStructBegin()
12387 
    while True:
12388 
      (fname, ftype, fid) = iprot.readFieldBegin()
12389 
      if ftype == TType.STOP:
12390 
        break
12391 
      if fid == 0:
575 chandransh 12392 
        if ftype == TType.I64:
12393 
          self.success = iprot.readI64();
94 ashish 12394 
        else:
12395 
          iprot.skip(ftype)
12396 
      elif fid == 1:
12397 
        if ftype == TType.STRUCT:
559 chandransh 12398 
          self.scx = ShoppingCartException()
12399 
          self.scx.read(iprot)
94 ashish 12400 
        else:
12401 
          iprot.skip(ftype)
12402 
      else:
12403 
        iprot.skip(ftype)
12404 
      iprot.readFieldEnd()
12405 
    iprot.readStructEnd()
12406 
 
12407 
  def write(self, oprot):
12408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12410 
      return
690 chandransh 12411 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12412 
    if self.success is not None:
575 chandransh 12413 
      oprot.writeFieldBegin('success', TType.I64, 0)
12414 
      oprot.writeI64(self.success)
94 ashish 12415 
      oprot.writeFieldEnd()
3431 rajveer 12416 
    if self.scx is not None:
559 chandransh 12417 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12418 
      self.scx.write(oprot)
94 ashish 12419 
      oprot.writeFieldEnd()
12420 
    oprot.writeFieldStop()
12421 
    oprot.writeStructEnd()
12422 
 
3431 rajveer 12423 
  def validate(self):
12424 
    return
12425 
 
12426 
 
94 ashish 12427 
  def __repr__(self):
12428 
    L = ['%s=%r' % (key, value)
12429 
      for key, value in self.__dict__.iteritems()]
12430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12431 
 
12432 
  def __eq__(self, other):
12433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12434 
 
12435 
  def __ne__(self, other):
12436 
    return not (self == other)
12437 
 
559 chandransh 12438 
class validateCart_args:
94 ashish 12439 
  """
12440 
  Attributes:
559 chandransh 12441 
   - cartId
3557 rajveer 12442 
   - sourceId
94 ashish 12443 
  """
12444 
 
12445 
  thrift_spec = (
12446 
    None, # 0
559 chandransh 12447 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12448 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12449 
  )
12450 
 
3557 rajveer 12451 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12452 
    self.cartId = cartId
3557 rajveer 12453 
    self.sourceId = sourceId
94 ashish 12454 
 
12455 
  def read(self, iprot):
12456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12458 
      return
12459 
    iprot.readStructBegin()
12460 
    while True:
12461 
      (fname, ftype, fid) = iprot.readFieldBegin()
12462 
      if ftype == TType.STOP:
12463 
        break
12464 
      if fid == 1:
12465 
        if ftype == TType.I64:
559 chandransh 12466 
          self.cartId = iprot.readI64();
94 ashish 12467 
        else:
12468 
          iprot.skip(ftype)
3557 rajveer 12469 
      elif fid == 2:
12470 
        if ftype == TType.I64:
12471 
          self.sourceId = iprot.readI64();
12472 
        else:
12473 
          iprot.skip(ftype)
94 ashish 12474 
      else:
12475 
        iprot.skip(ftype)
12476 
      iprot.readFieldEnd()
12477 
    iprot.readStructEnd()
12478 
 
12479 
  def write(self, oprot):
12480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12482 
      return
559 chandransh 12483 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12484 
    if self.cartId is not None:
559 chandransh 12485 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12486 
      oprot.writeI64(self.cartId)
94 ashish 12487 
      oprot.writeFieldEnd()
3557 rajveer 12488 
    if self.sourceId is not None:
12489 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12490 
      oprot.writeI64(self.sourceId)
12491 
      oprot.writeFieldEnd()
94 ashish 12492 
    oprot.writeFieldStop()
12493 
    oprot.writeStructEnd()
12494 
 
3431 rajveer 12495 
  def validate(self):
12496 
    return
12497 
 
12498 
 
94 ashish 12499 
  def __repr__(self):
12500 
    L = ['%s=%r' % (key, value)
12501 
      for key, value in self.__dict__.iteritems()]
12502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12503 
 
12504 
  def __eq__(self, other):
12505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12506 
 
12507 
  def __ne__(self, other):
12508 
    return not (self == other)
12509 
 
559 chandransh 12510 
class validateCart_result:
94 ashish 12511 
  """
12512 
  Attributes:
12513 
   - success
575 chandransh 12514 
   - scex
94 ashish 12515 
  """
12516 
 
12517 
  thrift_spec = (
6736 amit.gupta 12518 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12519 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12520 
  )
12521 
 
575 chandransh 12522 
  def __init__(self, success=None, scex=None,):
94 ashish 12523 
    self.success = success
575 chandransh 12524 
    self.scex = scex
94 ashish 12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      if fid == 0:
6736 amit.gupta 12536 
        if ftype == TType.LIST:
12537 
          self.success = []
11592 amit.gupta 12538 
          (_etype170, _size167) = iprot.readListBegin()
12539 
          for _i171 in xrange(_size167):
12540 
            _elem172 = iprot.readString();
12541 
            self.success.append(_elem172)
6736 amit.gupta 12542 
          iprot.readListEnd()
94 ashish 12543 
        else:
12544 
          iprot.skip(ftype)
575 chandransh 12545 
      elif fid == 1:
12546 
        if ftype == TType.STRUCT:
12547 
          self.scex = ShoppingCartException()
12548 
          self.scex.read(iprot)
12549 
        else:
12550 
          iprot.skip(ftype)
94 ashish 12551 
      else:
12552 
        iprot.skip(ftype)
12553 
      iprot.readFieldEnd()
12554 
    iprot.readStructEnd()
12555 
 
12556 
  def write(self, oprot):
12557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12559 
      return
559 chandransh 12560 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12561 
    if self.success is not None:
6736 amit.gupta 12562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12563 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12564 
      for iter173 in self.success:
12565 
        oprot.writeString(iter173)
6736 amit.gupta 12566 
      oprot.writeListEnd()
94 ashish 12567 
      oprot.writeFieldEnd()
3431 rajveer 12568 
    if self.scex is not None:
575 chandransh 12569 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12570 
      self.scex.write(oprot)
12571 
      oprot.writeFieldEnd()
559 chandransh 12572 
    oprot.writeFieldStop()
12573 
    oprot.writeStructEnd()
12574 
 
3431 rajveer 12575 
  def validate(self):
12576 
    return
12577 
 
12578 
 
559 chandransh 12579 
  def __repr__(self):
12580 
    L = ['%s=%r' % (key, value)
12581 
      for key, value in self.__dict__.iteritems()]
12582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12583 
 
12584 
  def __eq__(self, other):
12585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12586 
 
12587 
  def __ne__(self, other):
12588 
    return not (self == other)
12589 
 
11980 amit.gupta 12590 
class validateCartWithDealerCoupon_args:
12591 
  """
12592 
  Attributes:
12593 
   - cartId
12594 
   - sourceId
12595 
   - dealCoupon
12596 
  """
12597 
 
12598 
  thrift_spec = (
12599 
    None, # 0
12600 
    (1, TType.I64, 'cartId', None, None, ), # 1
12601 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12602 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12603 
  )
12604 
 
12605 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12606 
    self.cartId = cartId
12607 
    self.sourceId = sourceId
12608 
    self.dealCoupon = dealCoupon
12609 
 
12610 
  def read(self, iprot):
12611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12613 
      return
12614 
    iprot.readStructBegin()
12615 
    while True:
12616 
      (fname, ftype, fid) = iprot.readFieldBegin()
12617 
      if ftype == TType.STOP:
12618 
        break
12619 
      if fid == 1:
12620 
        if ftype == TType.I64:
12621 
          self.cartId = iprot.readI64();
12622 
        else:
12623 
          iprot.skip(ftype)
12624 
      elif fid == 2:
12625 
        if ftype == TType.I64:
12626 
          self.sourceId = iprot.readI64();
12627 
        else:
12628 
          iprot.skip(ftype)
12629 
      elif fid == 3:
12630 
        if ftype == TType.STRING:
12631 
          self.dealCoupon = iprot.readString();
12632 
        else:
12633 
          iprot.skip(ftype)
12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
12643 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12644 
    if self.cartId is not None:
12645 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12646 
      oprot.writeI64(self.cartId)
12647 
      oprot.writeFieldEnd()
12648 
    if self.sourceId is not None:
12649 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12650 
      oprot.writeI64(self.sourceId)
12651 
      oprot.writeFieldEnd()
12652 
    if self.dealCoupon is not None:
12653 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12654 
      oprot.writeString(self.dealCoupon)
12655 
      oprot.writeFieldEnd()
12656 
    oprot.writeFieldStop()
12657 
    oprot.writeStructEnd()
12658 
 
12659 
  def validate(self):
12660 
    return
12661 
 
12662 
 
12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
12674 
class validateCartWithDealerCoupon_result:
12675 
  """
12676 
  Attributes:
12677 
   - success
12678 
   - scex
12679 
  """
12680 
 
12681 
  thrift_spec = (
12682 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12683 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12684 
  )
12685 
 
12686 
  def __init__(self, success=None, scex=None,):
12687 
    self.success = success
12688 
    self.scex = scex
12689 
 
12690 
  def read(self, iprot):
12691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12693 
      return
12694 
    iprot.readStructBegin()
12695 
    while True:
12696 
      (fname, ftype, fid) = iprot.readFieldBegin()
12697 
      if ftype == TType.STOP:
12698 
        break
12699 
      if fid == 0:
12700 
        if ftype == TType.LIST:
12701 
          self.success = []
12702 
          (_etype177, _size174) = iprot.readListBegin()
12703 
          for _i178 in xrange(_size174):
12704 
            _elem179 = iprot.readString();
12705 
            self.success.append(_elem179)
12706 
          iprot.readListEnd()
12707 
        else:
12708 
          iprot.skip(ftype)
12709 
      elif fid == 1:
12710 
        if ftype == TType.STRUCT:
12711 
          self.scex = ShoppingCartException()
12712 
          self.scex.read(iprot)
12713 
        else:
12714 
          iprot.skip(ftype)
12715 
      else:
12716 
        iprot.skip(ftype)
12717 
      iprot.readFieldEnd()
12718 
    iprot.readStructEnd()
12719 
 
12720 
  def write(self, oprot):
12721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12723 
      return
12724 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12725 
    if self.success is not None:
12726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12727 
      oprot.writeListBegin(TType.STRING, len(self.success))
12728 
      for iter180 in self.success:
12729 
        oprot.writeString(iter180)
12730 
      oprot.writeListEnd()
12731 
      oprot.writeFieldEnd()
12732 
    if self.scex is not None:
12733 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12734 
      self.scex.write(oprot)
12735 
      oprot.writeFieldEnd()
12736 
    oprot.writeFieldStop()
12737 
    oprot.writeStructEnd()
12738 
 
12739 
  def validate(self):
12740 
    return
12741 
 
12742 
 
12743 
  def __repr__(self):
12744 
    L = ['%s=%r' % (key, value)
12745 
      for key, value in self.__dict__.iteritems()]
12746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12747 
 
12748 
  def __eq__(self, other):
12749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12750 
 
12751 
  def __ne__(self, other):
12752 
    return not (self == other)
12753 
 
690 chandransh 12754 
class mergeCart_args:
575 chandransh 12755 
  """
12756 
  Attributes:
690 chandransh 12757 
   - fromCartId
12758 
   - toCartId
12759 
  """
12760 
 
12761 
  thrift_spec = (
12762 
    None, # 0
12763 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12764 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12765 
  )
12766 
 
12767 
  def __init__(self, fromCartId=None, toCartId=None,):
12768 
    self.fromCartId = fromCartId
12769 
    self.toCartId = toCartId
12770 
 
12771 
  def read(self, iprot):
12772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12774 
      return
12775 
    iprot.readStructBegin()
12776 
    while True:
12777 
      (fname, ftype, fid) = iprot.readFieldBegin()
12778 
      if ftype == TType.STOP:
12779 
        break
12780 
      if fid == 1:
12781 
        if ftype == TType.I64:
12782 
          self.fromCartId = iprot.readI64();
12783 
        else:
12784 
          iprot.skip(ftype)
12785 
      elif fid == 2:
12786 
        if ftype == TType.I64:
12787 
          self.toCartId = iprot.readI64();
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      else:
12791 
        iprot.skip(ftype)
12792 
      iprot.readFieldEnd()
12793 
    iprot.readStructEnd()
12794 
 
12795 
  def write(self, oprot):
12796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12798 
      return
12799 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12800 
    if self.fromCartId is not None:
690 chandransh 12801 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12802 
      oprot.writeI64(self.fromCartId)
12803 
      oprot.writeFieldEnd()
3431 rajveer 12804 
    if self.toCartId is not None:
690 chandransh 12805 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12806 
      oprot.writeI64(self.toCartId)
12807 
      oprot.writeFieldEnd()
12808 
    oprot.writeFieldStop()
12809 
    oprot.writeStructEnd()
12810 
 
3431 rajveer 12811 
  def validate(self):
12812 
    return
12813 
 
12814 
 
690 chandransh 12815 
  def __repr__(self):
12816 
    L = ['%s=%r' % (key, value)
12817 
      for key, value in self.__dict__.iteritems()]
12818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12819 
 
12820 
  def __eq__(self, other):
12821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12822 
 
12823 
  def __ne__(self, other):
12824 
    return not (self == other)
12825 
 
12826 
class mergeCart_result:
12827 
 
12828 
  thrift_spec = (
12829 
  )
12830 
 
12831 
  def read(self, iprot):
12832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12834 
      return
12835 
    iprot.readStructBegin()
12836 
    while True:
12837 
      (fname, ftype, fid) = iprot.readFieldBegin()
12838 
      if ftype == TType.STOP:
12839 
        break
12840 
      else:
12841 
        iprot.skip(ftype)
12842 
      iprot.readFieldEnd()
12843 
    iprot.readStructEnd()
12844 
 
12845 
  def write(self, oprot):
12846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12848 
      return
12849 
    oprot.writeStructBegin('mergeCart_result')
12850 
    oprot.writeFieldStop()
12851 
    oprot.writeStructEnd()
12852 
 
3431 rajveer 12853 
  def validate(self):
12854 
    return
12855 
 
12856 
 
690 chandransh 12857 
  def __repr__(self):
12858 
    L = ['%s=%r' % (key, value)
12859 
      for key, value in self.__dict__.iteritems()]
12860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12861 
 
12862 
  def __eq__(self, other):
12863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12864 
 
12865 
  def __ne__(self, other):
12866 
    return not (self == other)
12867 
 
12868 
class checkOut_args:
12869 
  """
12870 
  Attributes:
575 chandransh 12871 
   - cartId
12872 
  """
12873 
 
12874 
  thrift_spec = (
12875 
    None, # 0
12876 
    (1, TType.I64, 'cartId', None, None, ), # 1
12877 
  )
12878 
 
12879 
  def __init__(self, cartId=None,):
12880 
    self.cartId = cartId
12881 
 
12882 
  def read(self, iprot):
12883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12885 
      return
12886 
    iprot.readStructBegin()
12887 
    while True:
12888 
      (fname, ftype, fid) = iprot.readFieldBegin()
12889 
      if ftype == TType.STOP:
12890 
        break
12891 
      if fid == 1:
12892 
        if ftype == TType.I64:
12893 
          self.cartId = iprot.readI64();
12894 
        else:
12895 
          iprot.skip(ftype)
12896 
      else:
12897 
        iprot.skip(ftype)
12898 
      iprot.readFieldEnd()
12899 
    iprot.readStructEnd()
12900 
 
12901 
  def write(self, oprot):
12902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12904 
      return
690 chandransh 12905 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12906 
    if self.cartId is not None:
575 chandransh 12907 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12908 
      oprot.writeI64(self.cartId)
12909 
      oprot.writeFieldEnd()
12910 
    oprot.writeFieldStop()
12911 
    oprot.writeStructEnd()
12912 
 
3431 rajveer 12913 
  def validate(self):
12914 
    return
12915 
 
12916 
 
575 chandransh 12917 
  def __repr__(self):
12918 
    L = ['%s=%r' % (key, value)
12919 
      for key, value in self.__dict__.iteritems()]
12920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12921 
 
12922 
  def __eq__(self, other):
12923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12924 
 
12925 
  def __ne__(self, other):
12926 
    return not (self == other)
12927 
 
690 chandransh 12928 
class checkOut_result:
575 chandransh 12929 
  """
12930 
  Attributes:
12931 
   - success
12932 
   - scex
12933 
  """
12934 
 
12935 
  thrift_spec = (
12936 
    (0, TType.BOOL, 'success', None, None, ), # 0
12937 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12938 
  )
12939 
 
12940 
  def __init__(self, success=None, scex=None,):
12941 
    self.success = success
12942 
    self.scex = scex
12943 
 
12944 
  def read(self, iprot):
12945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12947 
      return
12948 
    iprot.readStructBegin()
12949 
    while True:
12950 
      (fname, ftype, fid) = iprot.readFieldBegin()
12951 
      if ftype == TType.STOP:
12952 
        break
12953 
      if fid == 0:
12954 
        if ftype == TType.BOOL:
12955 
          self.success = iprot.readBool();
12956 
        else:
12957 
          iprot.skip(ftype)
12958 
      elif fid == 1:
12959 
        if ftype == TType.STRUCT:
12960 
          self.scex = ShoppingCartException()
12961 
          self.scex.read(iprot)
12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
690 chandransh 12973 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12974 
    if self.success is not None:
575 chandransh 12975 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12976 
      oprot.writeBool(self.success)
12977 
      oprot.writeFieldEnd()
3431 rajveer 12978 
    if self.scex is not None:
575 chandransh 12979 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12980 
      self.scex.write(oprot)
12981 
      oprot.writeFieldEnd()
12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
3431 rajveer 12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
575 chandransh 12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
690 chandransh 13000 
class resetCart_args:
559 chandransh 13001 
  """
13002 
  Attributes:
690 chandransh 13003 
   - cartId
13004 
   - items
559 chandransh 13005 
  """
13006 
 
13007 
  thrift_spec = (
13008 
    None, # 0
690 chandransh 13009 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 13010 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 13011 
  )
13012 
 
690 chandransh 13013 
  def __init__(self, cartId=None, items=None,):
13014 
    self.cartId = cartId
13015 
    self.items = items
559 chandransh 13016 
 
13017 
  def read(self, iprot):
13018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13020 
      return
13021 
    iprot.readStructBegin()
13022 
    while True:
13023 
      (fname, ftype, fid) = iprot.readFieldBegin()
13024 
      if ftype == TType.STOP:
13025 
        break
13026 
      if fid == 1:
13027 
        if ftype == TType.I64:
690 chandransh 13028 
          self.cartId = iprot.readI64();
559 chandransh 13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      elif fid == 2:
690 chandransh 13032 
        if ftype == TType.MAP:
13033 
          self.items = {}
11980 amit.gupta 13034 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
13035 
          for _i185 in xrange(_size181):
13036 
            _key186 = iprot.readI64();
13037 
            _val187 = iprot.readDouble();
13038 
            self.items[_key186] = _val187
690 chandransh 13039 
          iprot.readMapEnd()
559 chandransh 13040 
        else:
13041 
          iprot.skip(ftype)
13042 
      else:
13043 
        iprot.skip(ftype)
13044 
      iprot.readFieldEnd()
13045 
    iprot.readStructEnd()
13046 
 
13047 
  def write(self, oprot):
13048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13050 
      return
690 chandransh 13051 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13052 
    if self.cartId is not None:
690 chandransh 13053 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13054 
      oprot.writeI64(self.cartId)
94 ashish 13055 
      oprot.writeFieldEnd()
3431 rajveer 13056 
    if self.items is not None:
690 chandransh 13057 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13058 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13059 
      for kiter188,viter189 in self.items.items():
13060 
        oprot.writeI64(kiter188)
13061 
        oprot.writeDouble(viter189)
690 chandransh 13062 
      oprot.writeMapEnd()
559 chandransh 13063 
      oprot.writeFieldEnd()
94 ashish 13064 
    oprot.writeFieldStop()
13065 
    oprot.writeStructEnd()
13066 
 
3431 rajveer 13067 
  def validate(self):
13068 
    return
13069 
 
13070 
 
94 ashish 13071 
  def __repr__(self):
13072 
    L = ['%s=%r' % (key, value)
13073 
      for key, value in self.__dict__.iteritems()]
13074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13075 
 
13076 
  def __eq__(self, other):
13077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13078 
 
13079 
  def __ne__(self, other):
13080 
    return not (self == other)
13081 
 
690 chandransh 13082 
class resetCart_result:
13083 
  """
13084 
  Attributes:
13085 
   - success
13086 
   - scex
13087 
  """
559 chandransh 13088 
 
13089 
  thrift_spec = (
690 chandransh 13090 
    (0, TType.BOOL, 'success', None, None, ), # 0
13091 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13092 
  )
13093 
 
690 chandransh 13094 
  def __init__(self, success=None, scex=None,):
13095 
    self.success = success
13096 
    self.scex = scex
13097 
 
559 chandransh 13098 
  def read(self, iprot):
13099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13101 
      return
13102 
    iprot.readStructBegin()
13103 
    while True:
13104 
      (fname, ftype, fid) = iprot.readFieldBegin()
13105 
      if ftype == TType.STOP:
13106 
        break
690 chandransh 13107 
      if fid == 0:
13108 
        if ftype == TType.BOOL:
13109 
          self.success = iprot.readBool();
13110 
        else:
13111 
          iprot.skip(ftype)
13112 
      elif fid == 1:
13113 
        if ftype == TType.STRUCT:
13114 
          self.scex = ShoppingCartException()
13115 
          self.scex.read(iprot)
13116 
        else:
13117 
          iprot.skip(ftype)
559 chandransh 13118 
      else:
13119 
        iprot.skip(ftype)
13120 
      iprot.readFieldEnd()
13121 
    iprot.readStructEnd()
13122 
 
13123 
  def write(self, oprot):
13124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13126 
      return
690 chandransh 13127 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13128 
    if self.success is not None:
690 chandransh 13129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13130 
      oprot.writeBool(self.success)
13131 
      oprot.writeFieldEnd()
3431 rajveer 13132 
    if self.scex is not None:
690 chandransh 13133 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13134 
      self.scex.write(oprot)
13135 
      oprot.writeFieldEnd()
559 chandransh 13136 
    oprot.writeFieldStop()
13137 
    oprot.writeStructEnd()
13138 
 
3431 rajveer 13139 
  def validate(self):
13140 
    return
13141 
 
13142 
 
559 chandransh 13143 
  def __repr__(self):
13144 
    L = ['%s=%r' % (key, value)
13145 
      for key, value in self.__dict__.iteritems()]
13146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13147 
 
13148 
  def __eq__(self, other):
13149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13150 
 
13151 
  def __ne__(self, other):
13152 
    return not (self == other)
13153 
 
2981 rajveer 13154 
class getUserCount_args:
94 ashish 13155 
  """
13156 
  Attributes:
2981 rajveer 13157 
   - userType
559 chandransh 13158 
  """
13159 
 
13160 
  thrift_spec = (
13161 
    None, # 0
2981 rajveer 13162 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13163 
  )
13164 
 
2981 rajveer 13165 
  def __init__(self, userType=None,):
13166 
    self.userType = userType
559 chandransh 13167 
 
13168 
  def read(self, iprot):
13169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13171 
      return
13172 
    iprot.readStructBegin()
13173 
    while True:
13174 
      (fname, ftype, fid) = iprot.readFieldBegin()
13175 
      if ftype == TType.STOP:
13176 
        break
13177 
      if fid == 1:
2981 rajveer 13178 
        if ftype == TType.I32:
13179 
          self.userType = iprot.readI32();
559 chandransh 13180 
        else:
13181 
          iprot.skip(ftype)
13182 
      else:
13183 
        iprot.skip(ftype)
13184 
      iprot.readFieldEnd()
13185 
    iprot.readStructEnd()
13186 
 
13187 
  def write(self, oprot):
13188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13190 
      return
2981 rajveer 13191 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13192 
    if self.userType is not None:
2981 rajveer 13193 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13194 
      oprot.writeI32(self.userType)
559 chandransh 13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
3431 rajveer 13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
559 chandransh 13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
2981 rajveer 13214 
class getUserCount_result:
94 ashish 13215 
  """
13216 
  Attributes:
13217 
   - success
13218 
  """
13219 
 
13220 
  thrift_spec = (
2981 rajveer 13221 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13222 
  )
13223 
 
2981 rajveer 13224 
  def __init__(self, success=None,):
94 ashish 13225 
    self.success = success
13226 
 
13227 
  def read(self, iprot):
13228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13230 
      return
13231 
    iprot.readStructBegin()
13232 
    while True:
13233 
      (fname, ftype, fid) = iprot.readFieldBegin()
13234 
      if ftype == TType.STOP:
13235 
        break
13236 
      if fid == 0:
2981 rajveer 13237 
        if ftype == TType.I64:
13238 
          self.success = iprot.readI64();
94 ashish 13239 
        else:
13240 
          iprot.skip(ftype)
13241 
      else:
13242 
        iprot.skip(ftype)
13243 
      iprot.readFieldEnd()
13244 
    iprot.readStructEnd()
13245 
 
13246 
  def write(self, oprot):
13247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13249 
      return
2981 rajveer 13250 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13251 
    if self.success is not None:
2981 rajveer 13252 
      oprot.writeFieldBegin('success', TType.I64, 0)
13253 
      oprot.writeI64(self.success)
94 ashish 13254 
      oprot.writeFieldEnd()
13255 
    oprot.writeFieldStop()
13256 
    oprot.writeStructEnd()
13257 
 
3431 rajveer 13258 
  def validate(self):
13259 
    return
13260 
 
13261 
 
94 ashish 13262 
  def __repr__(self):
13263 
    L = ['%s=%r' % (key, value)
13264 
      for key, value in self.__dict__.iteritems()]
13265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13266 
 
13267 
  def __eq__(self, other):
13268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13269 
 
13270 
  def __ne__(self, other):
13271 
    return not (self == other)
13272 
 
2981 rajveer 13273 
class getAllUsers_args:
94 ashish 13274 
  """
13275 
  Attributes:
2981 rajveer 13276 
   - userType
13277 
   - startDate
13278 
   - endDate
94 ashish 13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    None, # 0
2981 rajveer 13283 
    (1, TType.I32, 'userType', None, None, ), # 1
13284 
    (2, TType.I64, 'startDate', None, None, ), # 2
13285 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13286 
  )
13287 
 
2981 rajveer 13288 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13289 
    self.userType = userType
13290 
    self.startDate = startDate
13291 
    self.endDate = endDate
94 ashish 13292 
 
13293 
  def read(self, iprot):
13294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13296 
      return
13297 
    iprot.readStructBegin()
13298 
    while True:
13299 
      (fname, ftype, fid) = iprot.readFieldBegin()
13300 
      if ftype == TType.STOP:
13301 
        break
13302 
      if fid == 1:
2981 rajveer 13303 
        if ftype == TType.I32:
13304 
          self.userType = iprot.readI32();
94 ashish 13305 
        else:
13306 
          iprot.skip(ftype)
13307 
      elif fid == 2:
559 chandransh 13308 
        if ftype == TType.I64:
2981 rajveer 13309 
          self.startDate = iprot.readI64();
94 ashish 13310 
        else:
13311 
          iprot.skip(ftype)
2981 rajveer 13312 
      elif fid == 3:
13313 
        if ftype == TType.I64:
13314 
          self.endDate = iprot.readI64();
13315 
        else:
13316 
          iprot.skip(ftype)
94 ashish 13317 
      else:
13318 
        iprot.skip(ftype)
13319 
      iprot.readFieldEnd()
13320 
    iprot.readStructEnd()
13321 
 
13322 
  def write(self, oprot):
13323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13325 
      return
2981 rajveer 13326 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13327 
    if self.userType is not None:
2981 rajveer 13328 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13329 
      oprot.writeI32(self.userType)
94 ashish 13330 
      oprot.writeFieldEnd()
3431 rajveer 13331 
    if self.startDate is not None:
2981 rajveer 13332 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13333 
      oprot.writeI64(self.startDate)
94 ashish 13334 
      oprot.writeFieldEnd()
3431 rajveer 13335 
    if self.endDate is not None:
2981 rajveer 13336 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13337 
      oprot.writeI64(self.endDate)
13338 
      oprot.writeFieldEnd()
94 ashish 13339 
    oprot.writeFieldStop()
13340 
    oprot.writeStructEnd()
13341 
 
3431 rajveer 13342 
  def validate(self):
13343 
    return
13344 
 
13345 
 
94 ashish 13346 
  def __repr__(self):
13347 
    L = ['%s=%r' % (key, value)
13348 
      for key, value in self.__dict__.iteritems()]
13349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13350 
 
13351 
  def __eq__(self, other):
13352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13353 
 
13354 
  def __ne__(self, other):
13355 
    return not (self == other)
13356 
 
2981 rajveer 13357 
class getAllUsers_result:
94 ashish 13358 
  """
13359 
  Attributes:
13360 
   - success
13361 
  """
13362 
 
13363 
  thrift_spec = (
2981 rajveer 13364 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13365 
  )
13366 
 
2981 rajveer 13367 
  def __init__(self, success=None,):
94 ashish 13368 
    self.success = success
13369 
 
13370 
  def read(self, iprot):
13371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13373 
      return
13374 
    iprot.readStructBegin()
13375 
    while True:
13376 
      (fname, ftype, fid) = iprot.readFieldBegin()
13377 
      if ftype == TType.STOP:
13378 
        break
13379 
      if fid == 0:
2981 rajveer 13380 
        if ftype == TType.LIST:
13381 
          self.success = []
11980 amit.gupta 13382 
          (_etype193, _size190) = iprot.readListBegin()
13383 
          for _i194 in xrange(_size190):
13384 
            _elem195 = User()
13385 
            _elem195.read(iprot)
13386 
            self.success.append(_elem195)
2981 rajveer 13387 
          iprot.readListEnd()
94 ashish 13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
2981 rajveer 13399 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13400 
    if self.success is not None:
2981 rajveer 13401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13403 
      for iter196 in self.success:
13404 
        iter196.write(oprot)
2981 rajveer 13405 
      oprot.writeListEnd()
94 ashish 13406 
      oprot.writeFieldEnd()
13407 
    oprot.writeFieldStop()
13408 
    oprot.writeStructEnd()
13409 
 
3431 rajveer 13410 
  def validate(self):
13411 
    return
13412 
 
13413 
 
94 ashish 13414 
  def __repr__(self):
13415 
    L = ['%s=%r' % (key, value)
13416 
      for key, value in self.__dict__.iteritems()]
13417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13418 
 
13419 
  def __eq__(self, other):
13420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13421 
 
13422 
  def __ne__(self, other):
13423 
    return not (self == other)
13424 
 
2981 rajveer 13425 
class getMyResearchItems_args:
559 chandransh 13426 
  """
13427 
  Attributes:
772 rajveer 13428 
   - userId
559 chandransh 13429 
  """
13430 
 
13431 
  thrift_spec = (
13432 
    None, # 0
772 rajveer 13433 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13434 
  )
13435 
 
772 rajveer 13436 
  def __init__(self, userId=None,):
13437 
    self.userId = userId
559 chandransh 13438 
 
13439 
  def read(self, iprot):
13440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13442 
      return
13443 
    iprot.readStructBegin()
13444 
    while True:
13445 
      (fname, ftype, fid) = iprot.readFieldBegin()
13446 
      if ftype == TType.STOP:
13447 
        break
13448 
      if fid == 1:
13449 
        if ftype == TType.I64:
772 rajveer 13450 
          self.userId = iprot.readI64();
559 chandransh 13451 
        else:
13452 
          iprot.skip(ftype)
13453 
      else:
13454 
        iprot.skip(ftype)
13455 
      iprot.readFieldEnd()
13456 
    iprot.readStructEnd()
13457 
 
13458 
  def write(self, oprot):
13459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13461 
      return
2981 rajveer 13462 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13463 
    if self.userId is not None:
772 rajveer 13464 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13465 
      oprot.writeI64(self.userId)
559 chandransh 13466 
      oprot.writeFieldEnd()
13467 
    oprot.writeFieldStop()
13468 
    oprot.writeStructEnd()
13469 
 
3431 rajveer 13470 
  def validate(self):
13471 
    return
13472 
 
13473 
 
559 chandransh 13474 
  def __repr__(self):
13475 
    L = ['%s=%r' % (key, value)
13476 
      for key, value in self.__dict__.iteritems()]
13477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13478 
 
13479 
  def __eq__(self, other):
13480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13481 
 
13482 
  def __ne__(self, other):
13483 
    return not (self == other)
13484 
 
2981 rajveer 13485 
class getMyResearchItems_result:
559 chandransh 13486 
  """
13487 
  Attributes:
130 ashish 13488 
   - success
559 chandransh 13489 
   - scx
130 ashish 13490 
  """
13491 
 
13492 
  thrift_spec = (
2981 rajveer 13493 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13494 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13495 
  )
13496 
 
559 chandransh 13497 
  def __init__(self, success=None, scx=None,):
130 ashish 13498 
    self.success = success
559 chandransh 13499 
    self.scx = scx
130 ashish 13500 
 
13501 
  def read(self, iprot):
13502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13504 
      return
13505 
    iprot.readStructBegin()
13506 
    while True:
13507 
      (fname, ftype, fid) = iprot.readFieldBegin()
13508 
      if ftype == TType.STOP:
13509 
        break
13510 
      if fid == 0:
2981 rajveer 13511 
        if ftype == TType.LIST:
13512 
          self.success = []
11980 amit.gupta 13513 
          (_etype200, _size197) = iprot.readListBegin()
13514 
          for _i201 in xrange(_size197):
13515 
            _elem202 = iprot.readI64();
13516 
            self.success.append(_elem202)
2981 rajveer 13517 
          iprot.readListEnd()
130 ashish 13518 
        else:
13519 
          iprot.skip(ftype)
13520 
      elif fid == 1:
13521 
        if ftype == TType.STRUCT:
559 chandransh 13522 
          self.scx = WidgetException()
13523 
          self.scx.read(iprot)
130 ashish 13524 
        else:
13525 
          iprot.skip(ftype)
13526 
      else:
13527 
        iprot.skip(ftype)
13528 
      iprot.readFieldEnd()
13529 
    iprot.readStructEnd()
13530 
 
13531 
  def write(self, oprot):
13532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13534 
      return
2981 rajveer 13535 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13536 
    if self.success is not None:
2981 rajveer 13537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13538 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13539 
      for iter203 in self.success:
13540 
        oprot.writeI64(iter203)
2981 rajveer 13541 
      oprot.writeListEnd()
130 ashish 13542 
      oprot.writeFieldEnd()
3431 rajveer 13543 
    if self.scx is not None:
559 chandransh 13544 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13545 
      self.scx.write(oprot)
130 ashish 13546 
      oprot.writeFieldEnd()
13547 
    oprot.writeFieldStop()
13548 
    oprot.writeStructEnd()
13549 
 
3431 rajveer 13550 
  def validate(self):
13551 
    return
13552 
 
13553 
 
130 ashish 13554 
  def __repr__(self):
13555 
    L = ['%s=%r' % (key, value)
13556 
      for key, value in self.__dict__.iteritems()]
13557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13558 
 
13559 
  def __eq__(self, other):
13560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13561 
 
13562 
  def __ne__(self, other):
13563 
    return not (self == other)
13564 
 
2981 rajveer 13565 
class updateMyResearch_args:
130 ashish 13566 
  """
13567 
  Attributes:
2981 rajveer 13568 
   - userId
13569 
   - itemId
130 ashish 13570 
  """
13571 
 
13572 
  thrift_spec = (
13573 
    None, # 0
2981 rajveer 13574 
    (1, TType.I64, 'userId', None, None, ), # 1
13575 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13576 
  )
13577 
 
2981 rajveer 13578 
  def __init__(self, userId=None, itemId=None,):
13579 
    self.userId = userId
13580 
    self.itemId = itemId
130 ashish 13581 
 
13582 
  def read(self, iprot):
13583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13585 
      return
13586 
    iprot.readStructBegin()
13587 
    while True:
13588 
      (fname, ftype, fid) = iprot.readFieldBegin()
13589 
      if ftype == TType.STOP:
13590 
        break
13591 
      if fid == 1:
559 chandransh 13592 
        if ftype == TType.I64:
2981 rajveer 13593 
          self.userId = iprot.readI64();
130 ashish 13594 
        else:
13595 
          iprot.skip(ftype)
13596 
      elif fid == 2:
559 chandransh 13597 
        if ftype == TType.I64:
2981 rajveer 13598 
          self.itemId = iprot.readI64();
559 chandransh 13599 
        else:
13600 
          iprot.skip(ftype)
130 ashish 13601 
      else:
13602 
        iprot.skip(ftype)
13603 
      iprot.readFieldEnd()
13604 
    iprot.readStructEnd()
13605 
 
13606 
  def write(self, oprot):
13607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13609 
      return
2981 rajveer 13610 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13611 
    if self.userId is not None:
2981 rajveer 13612 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13613 
      oprot.writeI64(self.userId)
130 ashish 13614 
      oprot.writeFieldEnd()
3431 rajveer 13615 
    if self.itemId is not None:
2981 rajveer 13616 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13617 
      oprot.writeI64(self.itemId)
130 ashish 13618 
      oprot.writeFieldEnd()
13619 
    oprot.writeFieldStop()
13620 
    oprot.writeStructEnd()
13621 
 
3431 rajveer 13622 
  def validate(self):
13623 
    return
13624 
 
13625 
 
130 ashish 13626 
  def __repr__(self):
13627 
    L = ['%s=%r' % (key, value)
13628 
      for key, value in self.__dict__.iteritems()]
13629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13630 
 
13631 
  def __eq__(self, other):
13632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13633 
 
13634 
  def __ne__(self, other):
13635 
    return not (self == other)
13636 
 
2981 rajveer 13637 
class updateMyResearch_result:
13638 
  """
13639 
  Attributes:
13640 
   - success
13641 
   - scx
13642 
  """
559 chandransh 13643 
 
13644 
  thrift_spec = (
2981 rajveer 13645 
    (0, TType.BOOL, 'success', None, None, ), # 0
13646 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13647 
  )
13648 
 
2981 rajveer 13649 
  def __init__(self, success=None, scx=None,):
13650 
    self.success = success
13651 
    self.scx = scx
13652 
 
559 chandransh 13653 
  def read(self, iprot):
13654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13656 
      return
13657 
    iprot.readStructBegin()
13658 
    while True:
13659 
      (fname, ftype, fid) = iprot.readFieldBegin()
13660 
      if ftype == TType.STOP:
13661 
        break
2981 rajveer 13662 
      if fid == 0:
13663 
        if ftype == TType.BOOL:
13664 
          self.success = iprot.readBool();
13665 
        else:
13666 
          iprot.skip(ftype)
13667 
      elif fid == 1:
13668 
        if ftype == TType.STRUCT:
13669 
          self.scx = WidgetException()
13670 
          self.scx.read(iprot)
13671 
        else:
13672 
          iprot.skip(ftype)
559 chandransh 13673 
      else:
13674 
        iprot.skip(ftype)
13675 
      iprot.readFieldEnd()
13676 
    iprot.readStructEnd()
13677 
 
13678 
  def write(self, oprot):
13679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13681 
      return
2981 rajveer 13682 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13683 
    if self.success is not None:
2981 rajveer 13684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13685 
      oprot.writeBool(self.success)
13686 
      oprot.writeFieldEnd()
3431 rajveer 13687 
    if self.scx is not None:
2981 rajveer 13688 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13689 
      self.scx.write(oprot)
13690 
      oprot.writeFieldEnd()
559 chandransh 13691 
    oprot.writeFieldStop()
13692 
    oprot.writeStructEnd()
13693 
 
3431 rajveer 13694 
  def validate(self):
13695 
    return
13696 
 
13697 
 
559 chandransh 13698 
  def __repr__(self):
13699 
    L = ['%s=%r' % (key, value)
13700 
      for key, value in self.__dict__.iteritems()]
13701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13702 
 
13703 
  def __eq__(self, other):
13704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13705 
 
13706 
  def __ne__(self, other):
13707 
    return not (self == other)
13708 
 
2981 rajveer 13709 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13710 
  """
13711 
  Attributes:
2981 rajveer 13712 
   - userId
13713 
   - itemId
1596 ankur.sing 13714 
  """
559 chandransh 13715 
 
1596 ankur.sing 13716 
  thrift_spec = (
13717 
    None, # 0
2981 rajveer 13718 
    (1, TType.I64, 'userId', None, None, ), # 1
13719 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13720 
  )
13721 
 
2981 rajveer 13722 
  def __init__(self, userId=None, itemId=None,):
13723 
    self.userId = userId
13724 
    self.itemId = itemId
1596 ankur.sing 13725 
 
13726 
  def read(self, iprot):
13727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13729 
      return
13730 
    iprot.readStructBegin()
13731 
    while True:
13732 
      (fname, ftype, fid) = iprot.readFieldBegin()
13733 
      if ftype == TType.STOP:
13734 
        break
13735 
      if fid == 1:
2981 rajveer 13736 
        if ftype == TType.I64:
13737 
          self.userId = iprot.readI64();
1596 ankur.sing 13738 
        else:
13739 
          iprot.skip(ftype)
2981 rajveer 13740 
      elif fid == 2:
13741 
        if ftype == TType.I64:
13742 
          self.itemId = iprot.readI64();
13743 
        else:
13744 
          iprot.skip(ftype)
1596 ankur.sing 13745 
      else:
13746 
        iprot.skip(ftype)
13747 
      iprot.readFieldEnd()
13748 
    iprot.readStructEnd()
13749 
 
13750 
  def write(self, oprot):
13751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13753 
      return
2981 rajveer 13754 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13755 
    if self.userId is not None:
2981 rajveer 13756 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13757 
      oprot.writeI64(self.userId)
1596 ankur.sing 13758 
      oprot.writeFieldEnd()
3431 rajveer 13759 
    if self.itemId is not None:
2981 rajveer 13760 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13761 
      oprot.writeI64(self.itemId)
13762 
      oprot.writeFieldEnd()
1596 ankur.sing 13763 
    oprot.writeFieldStop()
13764 
    oprot.writeStructEnd()
13765 
 
3431 rajveer 13766 
  def validate(self):
13767 
    return
13768 
 
13769 
 
1596 ankur.sing 13770 
  def __repr__(self):
13771 
    L = ['%s=%r' % (key, value)
13772 
      for key, value in self.__dict__.iteritems()]
13773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13774 
 
13775 
  def __eq__(self, other):
13776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13777 
 
13778 
  def __ne__(self, other):
13779 
    return not (self == other)
13780 
 
2981 rajveer 13781 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13782 
  """
13783 
  Attributes:
2981 rajveer 13784 
   - scx
1596 ankur.sing 13785 
  """
13786 
 
13787 
  thrift_spec = (
2981 rajveer 13788 
    None, # 0
13789 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13790 
  )
13791 
 
2981 rajveer 13792 
  def __init__(self, scx=None,):
13793 
    self.scx = scx
1596 ankur.sing 13794 
 
13795 
  def read(self, iprot):
13796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13798 
      return
13799 
    iprot.readStructBegin()
13800 
    while True:
13801 
      (fname, ftype, fid) = iprot.readFieldBegin()
13802 
      if ftype == TType.STOP:
13803 
        break
2981 rajveer 13804 
      if fid == 1:
13805 
        if ftype == TType.STRUCT:
13806 
          self.scx = WidgetException()
13807 
          self.scx.read(iprot)
1596 ankur.sing 13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      else:
13811 
        iprot.skip(ftype)
13812 
      iprot.readFieldEnd()
13813 
    iprot.readStructEnd()
13814 
 
13815 
  def write(self, oprot):
13816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13818 
      return
2981 rajveer 13819 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13820 
    if self.scx is not None:
2981 rajveer 13821 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13822 
      self.scx.write(oprot)
1596 ankur.sing 13823 
      oprot.writeFieldEnd()
13824 
    oprot.writeFieldStop()
13825 
    oprot.writeStructEnd()
13826 
 
3431 rajveer 13827 
  def validate(self):
13828 
    return
13829 
 
13830 
 
1596 ankur.sing 13831 
  def __repr__(self):
13832 
    L = ['%s=%r' % (key, value)
13833 
      for key, value in self.__dict__.iteritems()]
13834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13835 
 
13836 
  def __eq__(self, other):
13837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13838 
 
13839 
  def __ne__(self, other):
13840 
    return not (self == other)
13841 
 
2981 rajveer 13842 
class getBrowseHistoryItems_args:
1673 ankur.sing 13843 
  """
13844 
  Attributes:
2981 rajveer 13845 
   - userId
1673 ankur.sing 13846 
  """
1596 ankur.sing 13847 
 
1673 ankur.sing 13848 
  thrift_spec = (
13849 
    None, # 0
2981 rajveer 13850 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13851 
  )
13852 
 
2981 rajveer 13853 
  def __init__(self, userId=None,):
13854 
    self.userId = userId
1673 ankur.sing 13855 
 
13856 
  def read(self, iprot):
13857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13859 
      return
13860 
    iprot.readStructBegin()
13861 
    while True:
13862 
      (fname, ftype, fid) = iprot.readFieldBegin()
13863 
      if ftype == TType.STOP:
13864 
        break
13865 
      if fid == 1:
1891 ankur.sing 13866 
        if ftype == TType.I64:
2981 rajveer 13867 
          self.userId = iprot.readI64();
1891 ankur.sing 13868 
        else:
13869 
          iprot.skip(ftype)
1673 ankur.sing 13870 
      else:
13871 
        iprot.skip(ftype)
13872 
      iprot.readFieldEnd()
13873 
    iprot.readStructEnd()
13874 
 
13875 
  def write(self, oprot):
13876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13878 
      return
2981 rajveer 13879 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13880 
    if self.userId is not None:
2981 rajveer 13881 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13882 
      oprot.writeI64(self.userId)
1673 ankur.sing 13883 
      oprot.writeFieldEnd()
13884 
    oprot.writeFieldStop()
13885 
    oprot.writeStructEnd()
13886 
 
3431 rajveer 13887 
  def validate(self):
13888 
    return
13889 
 
13890 
 
1673 ankur.sing 13891 
  def __repr__(self):
13892 
    L = ['%s=%r' % (key, value)
13893 
      for key, value in self.__dict__.iteritems()]
13894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13895 
 
13896 
  def __eq__(self, other):
13897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13898 
 
13899 
  def __ne__(self, other):
13900 
    return not (self == other)
13901 
 
2981 rajveer 13902 
class getBrowseHistoryItems_result:
1673 ankur.sing 13903 
  """
13904 
  Attributes:
13905 
   - success
2981 rajveer 13906 
   - scx
1673 ankur.sing 13907 
  """
13908 
 
13909 
  thrift_spec = (
2981 rajveer 13910 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13911 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13912 
  )
13913 
 
2981 rajveer 13914 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13915 
    self.success = success
2981 rajveer 13916 
    self.scx = scx
1673 ankur.sing 13917 
 
13918 
  def read(self, iprot):
13919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13921 
      return
13922 
    iprot.readStructBegin()
13923 
    while True:
13924 
      (fname, ftype, fid) = iprot.readFieldBegin()
13925 
      if ftype == TType.STOP:
13926 
        break
13927 
      if fid == 0:
13928 
        if ftype == TType.LIST:
13929 
          self.success = []
11980 amit.gupta 13930 
          (_etype207, _size204) = iprot.readListBegin()
13931 
          for _i208 in xrange(_size204):
13932 
            _elem209 = iprot.readI64();
13933 
            self.success.append(_elem209)
1673 ankur.sing 13934 
          iprot.readListEnd()
13935 
        else:
13936 
          iprot.skip(ftype)
2981 rajveer 13937 
      elif fid == 1:
13938 
        if ftype == TType.STRUCT:
13939 
          self.scx = WidgetException()
13940 
          self.scx.read(iprot)
13941 
        else:
13942 
          iprot.skip(ftype)
1673 ankur.sing 13943 
      else:
13944 
        iprot.skip(ftype)
13945 
      iprot.readFieldEnd()
13946 
    iprot.readStructEnd()
13947 
 
13948 
  def write(self, oprot):
13949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13951 
      return
2981 rajveer 13952 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13953 
    if self.success is not None:
1673 ankur.sing 13954 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13955 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13956 
      for iter210 in self.success:
13957 
        oprot.writeI64(iter210)
1673 ankur.sing 13958 
      oprot.writeListEnd()
13959 
      oprot.writeFieldEnd()
3431 rajveer 13960 
    if self.scx is not None:
2981 rajveer 13961 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13962 
      self.scx.write(oprot)
2642 varun.gupt 13963 
      oprot.writeFieldEnd()
13964 
    oprot.writeFieldStop()
13965 
    oprot.writeStructEnd()
13966 
 
3431 rajveer 13967 
  def validate(self):
13968 
    return
13969 
 
13970 
 
2642 varun.gupt 13971 
  def __repr__(self):
13972 
    L = ['%s=%r' % (key, value)
13973 
      for key, value in self.__dict__.iteritems()]
13974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13975 
 
13976 
  def __eq__(self, other):
13977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13978 
 
13979 
  def __ne__(self, other):
13980 
    return not (self == other)
13981 
 
2981 rajveer 13982 
class updateBrowseHistory_args:
2642 varun.gupt 13983 
  """
13984 
  Attributes:
2981 rajveer 13985 
   - userId
13986 
   - itemId
2642 varun.gupt 13987 
  """
13988 
 
13989 
  thrift_spec = (
13990 
    None, # 0
2981 rajveer 13991 
    (1, TType.I64, 'userId', None, None, ), # 1
13992 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13993 
  )
13994 
 
2981 rajveer 13995 
  def __init__(self, userId=None, itemId=None,):
13996 
    self.userId = userId
13997 
    self.itemId = itemId
2642 varun.gupt 13998 
 
13999 
  def read(self, iprot):
14000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14002 
      return
14003 
    iprot.readStructBegin()
14004 
    while True:
14005 
      (fname, ftype, fid) = iprot.readFieldBegin()
14006 
      if ftype == TType.STOP:
14007 
        break
14008 
      if fid == 1:
14009 
        if ftype == TType.I64:
2981 rajveer 14010 
          self.userId = iprot.readI64();
2642 varun.gupt 14011 
        else:
14012 
          iprot.skip(ftype)
14013 
      elif fid == 2:
14014 
        if ftype == TType.I64:
2981 rajveer 14015 
          self.itemId = iprot.readI64();
2642 varun.gupt 14016 
        else:
14017 
          iprot.skip(ftype)
14018 
      else:
14019 
        iprot.skip(ftype)
14020 
      iprot.readFieldEnd()
14021 
    iprot.readStructEnd()
14022 
 
14023 
  def write(self, oprot):
14024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14026 
      return
2981 rajveer 14027 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 14028 
    if self.userId is not None:
2981 rajveer 14029 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14030 
      oprot.writeI64(self.userId)
2642 varun.gupt 14031 
      oprot.writeFieldEnd()
3431 rajveer 14032 
    if self.itemId is not None:
2981 rajveer 14033 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14034 
      oprot.writeI64(self.itemId)
2642 varun.gupt 14035 
      oprot.writeFieldEnd()
14036 
    oprot.writeFieldStop()
14037 
    oprot.writeStructEnd()
14038 
 
3431 rajveer 14039 
  def validate(self):
14040 
    return
14041 
 
14042 
 
2642 varun.gupt 14043 
  def __repr__(self):
14044 
    L = ['%s=%r' % (key, value)
14045 
      for key, value in self.__dict__.iteritems()]
14046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14047 
 
14048 
  def __eq__(self, other):
14049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14050 
 
14051 
  def __ne__(self, other):
14052 
    return not (self == other)
14053 
 
2981 rajveer 14054 
class updateBrowseHistory_result:
2642 varun.gupt 14055 
 
14056 
  thrift_spec = (
14057 
  )
14058 
 
14059 
  def read(self, iprot):
14060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14062 
      return
14063 
    iprot.readStructBegin()
14064 
    while True:
14065 
      (fname, ftype, fid) = iprot.readFieldBegin()
14066 
      if ftype == TType.STOP:
14067 
        break
14068 
      else:
14069 
        iprot.skip(ftype)
14070 
      iprot.readFieldEnd()
14071 
    iprot.readStructEnd()
14072 
 
14073 
  def write(self, oprot):
14074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14076 
      return
2981 rajveer 14077 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14078 
    oprot.writeFieldStop()
14079 
    oprot.writeStructEnd()
14080 
 
3431 rajveer 14081 
  def validate(self):
14082 
    return
14083 
 
14084 
 
2642 varun.gupt 14085 
  def __repr__(self):
14086 
    L = ['%s=%r' % (key, value)
14087 
      for key, value in self.__dict__.iteritems()]
14088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14089 
 
14090 
  def __eq__(self, other):
14091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14092 
 
14093 
  def __ne__(self, other):
14094 
    return not (self == other)
14095 
 
3385 varun.gupt 14096 
class getCartsWithCouponCount_args:
14097 
  """
14098 
  Attributes:
14099 
   - couponCode
14100 
  """
2642 varun.gupt 14101 
 
3385 varun.gupt 14102 
  thrift_spec = (
14103 
    None, # 0
14104 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14105 
  )
14106 
 
14107 
  def __init__(self, couponCode=None,):
14108 
    self.couponCode = couponCode
14109 
 
14110 
  def read(self, iprot):
14111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14113 
      return
14114 
    iprot.readStructBegin()
14115 
    while True:
14116 
      (fname, ftype, fid) = iprot.readFieldBegin()
14117 
      if ftype == TType.STOP:
14118 
        break
14119 
      if fid == 1:
14120 
        if ftype == TType.STRING:
14121 
          self.couponCode = iprot.readString();
14122 
        else:
14123 
          iprot.skip(ftype)
14124 
      else:
14125 
        iprot.skip(ftype)
14126 
      iprot.readFieldEnd()
14127 
    iprot.readStructEnd()
14128 
 
14129 
  def write(self, oprot):
14130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14132 
      return
14133 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14134 
    if self.couponCode is not None:
3385 varun.gupt 14135 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14136 
      oprot.writeString(self.couponCode)
14137 
      oprot.writeFieldEnd()
14138 
    oprot.writeFieldStop()
14139 
    oprot.writeStructEnd()
14140 
 
3431 rajveer 14141 
  def validate(self):
14142 
    return
14143 
 
14144 
 
3385 varun.gupt 14145 
  def __repr__(self):
14146 
    L = ['%s=%r' % (key, value)
14147 
      for key, value in self.__dict__.iteritems()]
14148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14149 
 
14150 
  def __eq__(self, other):
14151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14152 
 
14153 
  def __ne__(self, other):
14154 
    return not (self == other)
14155 
 
14156 
class getCartsWithCouponCount_result:
14157 
  """
14158 
  Attributes:
14159 
   - success
14160 
  """
14161 
 
14162 
  thrift_spec = (
14163 
    (0, TType.I64, 'success', None, None, ), # 0
14164 
  )
14165 
 
14166 
  def __init__(self, success=None,):
14167 
    self.success = success
14168 
 
14169 
  def read(self, iprot):
14170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14172 
      return
14173 
    iprot.readStructBegin()
14174 
    while True:
14175 
      (fname, ftype, fid) = iprot.readFieldBegin()
14176 
      if ftype == TType.STOP:
14177 
        break
14178 
      if fid == 0:
14179 
        if ftype == TType.I64:
14180 
          self.success = iprot.readI64();
14181 
        else:
14182 
          iprot.skip(ftype)
14183 
      else:
14184 
        iprot.skip(ftype)
14185 
      iprot.readFieldEnd()
14186 
    iprot.readStructEnd()
14187 
 
14188 
  def write(self, oprot):
14189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14191 
      return
14192 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14193 
    if self.success is not None:
3385 varun.gupt 14194 
      oprot.writeFieldBegin('success', TType.I64, 0)
14195 
      oprot.writeI64(self.success)
14196 
      oprot.writeFieldEnd()
14197 
    oprot.writeFieldStop()
14198 
    oprot.writeStructEnd()
14199 
 
3431 rajveer 14200 
  def validate(self):
14201 
    return
14202 
 
14203 
 
3385 varun.gupt 14204 
  def __repr__(self):
14205 
    L = ['%s=%r' % (key, value)
14206 
      for key, value in self.__dict__.iteritems()]
14207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14208 
 
14209 
  def __eq__(self, other):
14210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14211 
 
14212 
  def __ne__(self, other):
14213 
    return not (self == other)
3499 mandeep.dh 14214 
 
14215 
class increaseTrustLevel_args:
14216 
  """
14217 
  Attributes:
14218 
   - userId
14219 
   - trustLevelDelta
14220 
  """
14221 
 
14222 
  thrift_spec = (
14223 
    None, # 0
14224 
    (1, TType.I64, 'userId', None, None, ), # 1
14225 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14226 
  )
14227 
 
14228 
  def __init__(self, userId=None, trustLevelDelta=None,):
14229 
    self.userId = userId
14230 
    self.trustLevelDelta = trustLevelDelta
14231 
 
14232 
  def read(self, iprot):
14233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14235 
      return
14236 
    iprot.readStructBegin()
14237 
    while True:
14238 
      (fname, ftype, fid) = iprot.readFieldBegin()
14239 
      if ftype == TType.STOP:
14240 
        break
14241 
      if fid == 1:
14242 
        if ftype == TType.I64:
14243 
          self.userId = iprot.readI64();
14244 
        else:
14245 
          iprot.skip(ftype)
14246 
      elif fid == 2:
14247 
        if ftype == TType.DOUBLE:
14248 
          self.trustLevelDelta = iprot.readDouble();
14249 
        else:
14250 
          iprot.skip(ftype)
14251 
      else:
14252 
        iprot.skip(ftype)
14253 
      iprot.readFieldEnd()
14254 
    iprot.readStructEnd()
14255 
 
14256 
  def write(self, oprot):
14257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14259 
      return
14260 
    oprot.writeStructBegin('increaseTrustLevel_args')
14261 
    if self.userId is not None:
14262 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14263 
      oprot.writeI64(self.userId)
14264 
      oprot.writeFieldEnd()
14265 
    if self.trustLevelDelta is not None:
14266 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14267 
      oprot.writeDouble(self.trustLevelDelta)
14268 
      oprot.writeFieldEnd()
14269 
    oprot.writeFieldStop()
14270 
    oprot.writeStructEnd()
14271 
 
14272 
  def validate(self):
14273 
    return
14274 
 
14275 
 
14276 
  def __repr__(self):
14277 
    L = ['%s=%r' % (key, value)
14278 
      for key, value in self.__dict__.iteritems()]
14279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14280 
 
14281 
  def __eq__(self, other):
14282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14283 
 
14284 
  def __ne__(self, other):
14285 
    return not (self == other)
4668 varun.gupt 14286 
 
5407 amar.kumar 14287 
class getTrustLevel_args:
14288 
  """
14289 
  Attributes:
14290 
   - userId
14291 
  """
14292 
 
14293 
  thrift_spec = (
14294 
    None, # 0
14295 
    (1, TType.I64, 'userId', None, None, ), # 1
14296 
  )
14297 
 
14298 
  def __init__(self, userId=None,):
14299 
    self.userId = userId
14300 
 
14301 
  def read(self, iprot):
14302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14304 
      return
14305 
    iprot.readStructBegin()
14306 
    while True:
14307 
      (fname, ftype, fid) = iprot.readFieldBegin()
14308 
      if ftype == TType.STOP:
14309 
        break
14310 
      if fid == 1:
14311 
        if ftype == TType.I64:
14312 
          self.userId = iprot.readI64();
14313 
        else:
14314 
          iprot.skip(ftype)
14315 
      else:
14316 
        iprot.skip(ftype)
14317 
      iprot.readFieldEnd()
14318 
    iprot.readStructEnd()
14319 
 
14320 
  def write(self, oprot):
14321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14323 
      return
14324 
    oprot.writeStructBegin('getTrustLevel_args')
14325 
    if self.userId is not None:
14326 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14327 
      oprot.writeI64(self.userId)
14328 
      oprot.writeFieldEnd()
14329 
    oprot.writeFieldStop()
14330 
    oprot.writeStructEnd()
14331 
 
14332 
  def validate(self):
14333 
    return
14334 
 
14335 
 
14336 
  def __repr__(self):
14337 
    L = ['%s=%r' % (key, value)
14338 
      for key, value in self.__dict__.iteritems()]
14339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14340 
 
14341 
  def __eq__(self, other):
14342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14343 
 
14344 
  def __ne__(self, other):
14345 
    return not (self == other)
14346 
 
14347 
class getTrustLevel_result:
14348 
  """
14349 
  Attributes:
14350 
   - success
14351 
  """
14352 
 
14353 
  thrift_spec = (
14354 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14355 
  )
14356 
 
14357 
  def __init__(self, success=None,):
14358 
    self.success = success
14359 
 
14360 
  def read(self, iprot):
14361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14363 
      return
14364 
    iprot.readStructBegin()
14365 
    while True:
14366 
      (fname, ftype, fid) = iprot.readFieldBegin()
14367 
      if ftype == TType.STOP:
14368 
        break
14369 
      if fid == 0:
14370 
        if ftype == TType.DOUBLE:
14371 
          self.success = iprot.readDouble();
14372 
        else:
14373 
          iprot.skip(ftype)
14374 
      else:
14375 
        iprot.skip(ftype)
14376 
      iprot.readFieldEnd()
14377 
    iprot.readStructEnd()
14378 
 
14379 
  def write(self, oprot):
14380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14382 
      return
14383 
    oprot.writeStructBegin('getTrustLevel_result')
14384 
    if self.success is not None:
14385 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14386 
      oprot.writeDouble(self.success)
14387 
      oprot.writeFieldEnd()
14388 
    oprot.writeFieldStop()
14389 
    oprot.writeStructEnd()
14390 
 
14391 
  def validate(self):
14392 
    return
14393 
 
14394 
 
14395 
  def __repr__(self):
14396 
    L = ['%s=%r' % (key, value)
14397 
      for key, value in self.__dict__.iteritems()]
14398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14399 
 
14400 
  def __eq__(self, other):
14401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14402 
 
14403 
  def __ne__(self, other):
14404 
    return not (self == other)
14405 
 
4668 varun.gupt 14406 
class showCODOption_args:
14407 
  """
14408 
  Attributes:
14409 
   - cartId
14410 
   - sourceId
14411 
   - pincode
14412 
  """
14413 
 
14414 
  thrift_spec = (
14415 
    None, # 0
14416 
    (1, TType.I64, 'cartId', None, None, ), # 1
14417 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14418 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14419 
  )
14420 
 
14421 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14422 
    self.cartId = cartId
14423 
    self.sourceId = sourceId
14424 
    self.pincode = pincode
14425 
 
14426 
  def read(self, iprot):
14427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14429 
      return
14430 
    iprot.readStructBegin()
14431 
    while True:
14432 
      (fname, ftype, fid) = iprot.readFieldBegin()
14433 
      if ftype == TType.STOP:
14434 
        break
14435 
      if fid == 1:
14436 
        if ftype == TType.I64:
14437 
          self.cartId = iprot.readI64();
14438 
        else:
14439 
          iprot.skip(ftype)
14440 
      elif fid == 2:
14441 
        if ftype == TType.I64:
14442 
          self.sourceId = iprot.readI64();
14443 
        else:
14444 
          iprot.skip(ftype)
14445 
      elif fid == 3:
14446 
        if ftype == TType.STRING:
14447 
          self.pincode = iprot.readString();
14448 
        else:
14449 
          iprot.skip(ftype)
14450 
      else:
14451 
        iprot.skip(ftype)
14452 
      iprot.readFieldEnd()
14453 
    iprot.readStructEnd()
14454 
 
14455 
  def write(self, oprot):
14456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14458 
      return
14459 
    oprot.writeStructBegin('showCODOption_args')
14460 
    if self.cartId is not None:
14461 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14462 
      oprot.writeI64(self.cartId)
14463 
      oprot.writeFieldEnd()
14464 
    if self.sourceId is not None:
14465 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14466 
      oprot.writeI64(self.sourceId)
14467 
      oprot.writeFieldEnd()
14468 
    if self.pincode is not None:
14469 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14470 
      oprot.writeString(self.pincode)
14471 
      oprot.writeFieldEnd()
14472 
    oprot.writeFieldStop()
14473 
    oprot.writeStructEnd()
14474 
 
14475 
  def validate(self):
14476 
    return
14477 
 
14478 
 
14479 
  def __repr__(self):
14480 
    L = ['%s=%r' % (key, value)
14481 
      for key, value in self.__dict__.iteritems()]
14482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14483 
 
14484 
  def __eq__(self, other):
14485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14486 
 
14487 
  def __ne__(self, other):
14488 
    return not (self == other)
14489 
 
14490 
class showCODOption_result:
14491 
  """
14492 
  Attributes:
14493 
   - success
14494 
  """
14495 
 
14496 
  thrift_spec = (
14497 
    (0, TType.BOOL, 'success', None, None, ), # 0
14498 
  )
14499 
 
14500 
  def __init__(self, success=None,):
14501 
    self.success = success
14502 
 
14503 
  def read(self, iprot):
14504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14506 
      return
14507 
    iprot.readStructBegin()
14508 
    while True:
14509 
      (fname, ftype, fid) = iprot.readFieldBegin()
14510 
      if ftype == TType.STOP:
14511 
        break
14512 
      if fid == 0:
14513 
        if ftype == TType.BOOL:
14514 
          self.success = iprot.readBool();
14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      else:
14518 
        iprot.skip(ftype)
14519 
      iprot.readFieldEnd()
14520 
    iprot.readStructEnd()
14521 
 
14522 
  def write(self, oprot):
14523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14525 
      return
14526 
    oprot.writeStructBegin('showCODOption_result')
14527 
    if self.success is not None:
14528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14529 
      oprot.writeBool(self.success)
14530 
      oprot.writeFieldEnd()
14531 
    oprot.writeFieldStop()
14532 
    oprot.writeStructEnd()
14533 
 
14534 
  def validate(self):
14535 
    return
14536 
 
14537 
 
14538 
  def __repr__(self):
14539 
    L = ['%s=%r' % (key, value)
14540 
      for key, value in self.__dict__.iteritems()]
14541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14542 
 
14543 
  def __eq__(self, other):
14544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14545 
 
14546 
  def __ne__(self, other):
14547 
    return not (self == other)
5623 anupam.sin 14548 
 
14549 
class getUserEmails_args:
14550 
  """
14551 
  Attributes:
14552 
   - startDate
14553 
   - endDate
14554 
  """
14555 
 
14556 
  thrift_spec = (
14557 
    None, # 0
14558 
    (1, TType.I64, 'startDate', None, None, ), # 1
14559 
    (2, TType.I64, 'endDate', None, None, ), # 2
14560 
  )
14561 
 
14562 
  def __init__(self, startDate=None, endDate=None,):
14563 
    self.startDate = startDate
14564 
    self.endDate = endDate
14565 
 
14566 
  def read(self, iprot):
14567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14569 
      return
14570 
    iprot.readStructBegin()
14571 
    while True:
14572 
      (fname, ftype, fid) = iprot.readFieldBegin()
14573 
      if ftype == TType.STOP:
14574 
        break
14575 
      if fid == 1:
14576 
        if ftype == TType.I64:
14577 
          self.startDate = iprot.readI64();
14578 
        else:
14579 
          iprot.skip(ftype)
14580 
      elif fid == 2:
14581 
        if ftype == TType.I64:
14582 
          self.endDate = iprot.readI64();
14583 
        else:
14584 
          iprot.skip(ftype)
14585 
      else:
14586 
        iprot.skip(ftype)
14587 
      iprot.readFieldEnd()
14588 
    iprot.readStructEnd()
14589 
 
14590 
  def write(self, oprot):
14591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14593 
      return
14594 
    oprot.writeStructBegin('getUserEmails_args')
14595 
    if self.startDate is not None:
14596 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14597 
      oprot.writeI64(self.startDate)
14598 
      oprot.writeFieldEnd()
14599 
    if self.endDate is not None:
14600 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14601 
      oprot.writeI64(self.endDate)
14602 
      oprot.writeFieldEnd()
14603 
    oprot.writeFieldStop()
14604 
    oprot.writeStructEnd()
14605 
 
14606 
  def validate(self):
14607 
    return
14608 
 
14609 
 
14610 
  def __repr__(self):
14611 
    L = ['%s=%r' % (key, value)
14612 
      for key, value in self.__dict__.iteritems()]
14613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14614 
 
14615 
  def __eq__(self, other):
14616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14617 
 
14618 
  def __ne__(self, other):
14619 
    return not (self == other)
14620 
 
14621 
class getUserEmails_result:
14622 
  """
14623 
  Attributes:
14624 
   - success
14625 
  """
14626 
 
14627 
  thrift_spec = (
14628 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14629 
  )
14630 
 
14631 
  def __init__(self, success=None,):
14632 
    self.success = success
14633 
 
14634 
  def read(self, iprot):
14635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14637 
      return
14638 
    iprot.readStructBegin()
14639 
    while True:
14640 
      (fname, ftype, fid) = iprot.readFieldBegin()
14641 
      if ftype == TType.STOP:
14642 
        break
14643 
      if fid == 0:
14644 
        if ftype == TType.LIST:
14645 
          self.success = []
11980 amit.gupta 14646 
          (_etype214, _size211) = iprot.readListBegin()
14647 
          for _i215 in xrange(_size211):
14648 
            _elem216 = iprot.readString();
14649 
            self.success.append(_elem216)
5623 anupam.sin 14650 
          iprot.readListEnd()
14651 
        else:
14652 
          iprot.skip(ftype)
14653 
      else:
14654 
        iprot.skip(ftype)
14655 
      iprot.readFieldEnd()
14656 
    iprot.readStructEnd()
14657 
 
14658 
  def write(self, oprot):
14659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14661 
      return
14662 
    oprot.writeStructBegin('getUserEmails_result')
14663 
    if self.success is not None:
14664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14665 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14666 
      for iter217 in self.success:
14667 
        oprot.writeString(iter217)
5623 anupam.sin 14668 
      oprot.writeListEnd()
14669 
      oprot.writeFieldEnd()
14670 
    oprot.writeFieldStop()
14671 
    oprot.writeStructEnd()
14672 
 
14673 
  def validate(self):
14674 
    return
14675 
 
14676 
 
14677 
  def __repr__(self):
14678 
    L = ['%s=%r' % (key, value)
14679 
      for key, value in self.__dict__.iteritems()]
14680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14681 
 
14682 
  def __eq__(self, other):
14683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14684 
 
14685 
  def __ne__(self, other):
14686 
    return not (self == other)
6821 amar.kumar 14687 
 
6903 anupam.sin 14688 
class insureItem_args:
14689 
  """
14690 
  Attributes:
14691 
   - itemId
14692 
   - cartId
14693 
   - toInsure
9299 kshitij.so 14694 
   - insurerType
6903 anupam.sin 14695 
  """
14696 
 
14697 
  thrift_spec = (
14698 
    None, # 0
14699 
    (1, TType.I64, 'itemId', None, None, ), # 1
14700 
    (2, TType.I64, 'cartId', None, None, ), # 2
14701 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14702 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14703 
  )
14704 
 
9299 kshitij.so 14705 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14706 
    self.itemId = itemId
14707 
    self.cartId = cartId
14708 
    self.toInsure = toInsure
9299 kshitij.so 14709 
    self.insurerType = insurerType
6903 anupam.sin 14710 
 
14711 
  def read(self, iprot):
14712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14714 
      return
14715 
    iprot.readStructBegin()
14716 
    while True:
14717 
      (fname, ftype, fid) = iprot.readFieldBegin()
14718 
      if ftype == TType.STOP:
14719 
        break
14720 
      if fid == 1:
14721 
        if ftype == TType.I64:
14722 
          self.itemId = iprot.readI64();
14723 
        else:
14724 
          iprot.skip(ftype)
14725 
      elif fid == 2:
14726 
        if ftype == TType.I64:
14727 
          self.cartId = iprot.readI64();
14728 
        else:
14729 
          iprot.skip(ftype)
14730 
      elif fid == 3:
14731 
        if ftype == TType.BOOL:
14732 
          self.toInsure = iprot.readBool();
14733 
        else:
14734 
          iprot.skip(ftype)
9299 kshitij.so 14735 
      elif fid == 4:
14736 
        if ftype == TType.I32:
14737 
          self.insurerType = iprot.readI32();
14738 
        else:
14739 
          iprot.skip(ftype)
6903 anupam.sin 14740 
      else:
14741 
        iprot.skip(ftype)
14742 
      iprot.readFieldEnd()
14743 
    iprot.readStructEnd()
14744 
 
14745 
  def write(self, oprot):
14746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14748 
      return
14749 
    oprot.writeStructBegin('insureItem_args')
14750 
    if self.itemId is not None:
14751 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14752 
      oprot.writeI64(self.itemId)
14753 
      oprot.writeFieldEnd()
14754 
    if self.cartId is not None:
14755 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14756 
      oprot.writeI64(self.cartId)
14757 
      oprot.writeFieldEnd()
14758 
    if self.toInsure is not None:
14759 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14760 
      oprot.writeBool(self.toInsure)
14761 
      oprot.writeFieldEnd()
9299 kshitij.so 14762 
    if self.insurerType is not None:
14763 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14764 
      oprot.writeI32(self.insurerType)
14765 
      oprot.writeFieldEnd()
6903 anupam.sin 14766 
    oprot.writeFieldStop()
14767 
    oprot.writeStructEnd()
14768 
 
14769 
  def validate(self):
14770 
    return
14771 
 
14772 
 
14773 
  def __repr__(self):
14774 
    L = ['%s=%r' % (key, value)
14775 
      for key, value in self.__dict__.iteritems()]
14776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14777 
 
14778 
  def __eq__(self, other):
14779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14780 
 
14781 
  def __ne__(self, other):
14782 
    return not (self == other)
14783 
 
14784 
class insureItem_result:
14785 
  """
14786 
  Attributes:
14787 
   - success
14788 
  """
14789 
 
14790 
  thrift_spec = (
14791 
    (0, TType.BOOL, 'success', None, None, ), # 0
14792 
  )
14793 
 
14794 
  def __init__(self, success=None,):
14795 
    self.success = success
14796 
 
14797 
  def read(self, iprot):
14798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14800 
      return
14801 
    iprot.readStructBegin()
14802 
    while True:
14803 
      (fname, ftype, fid) = iprot.readFieldBegin()
14804 
      if ftype == TType.STOP:
14805 
        break
14806 
      if fid == 0:
14807 
        if ftype == TType.BOOL:
14808 
          self.success = iprot.readBool();
14809 
        else:
14810 
          iprot.skip(ftype)
14811 
      else:
14812 
        iprot.skip(ftype)
14813 
      iprot.readFieldEnd()
14814 
    iprot.readStructEnd()
14815 
 
14816 
  def write(self, oprot):
14817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14819 
      return
14820 
    oprot.writeStructBegin('insureItem_result')
14821 
    if self.success is not None:
14822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14823 
      oprot.writeBool(self.success)
14824 
      oprot.writeFieldEnd()
14825 
    oprot.writeFieldStop()
14826 
    oprot.writeStructEnd()
14827 
 
14828 
  def validate(self):
14829 
    return
14830 
 
14831 
 
14832 
  def __repr__(self):
14833 
    L = ['%s=%r' % (key, value)
14834 
      for key, value in self.__dict__.iteritems()]
14835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14836 
 
14837 
  def __eq__(self, other):
14838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14839 
 
14840 
  def __ne__(self, other):
14841 
    return not (self == other)
14842 
 
14843 
class cancelInsurance_args:
14844 
  """
14845 
  Attributes:
14846 
   - cartId
14847 
  """
14848 
 
14849 
  thrift_spec = (
14850 
    None, # 0
14851 
    (1, TType.I64, 'cartId', None, None, ), # 1
14852 
  )
14853 
 
14854 
  def __init__(self, cartId=None,):
14855 
    self.cartId = cartId
14856 
 
14857 
  def read(self, iprot):
14858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14860 
      return
14861 
    iprot.readStructBegin()
14862 
    while True:
14863 
      (fname, ftype, fid) = iprot.readFieldBegin()
14864 
      if ftype == TType.STOP:
14865 
        break
14866 
      if fid == 1:
14867 
        if ftype == TType.I64:
14868 
          self.cartId = iprot.readI64();
14869 
        else:
14870 
          iprot.skip(ftype)
14871 
      else:
14872 
        iprot.skip(ftype)
14873 
      iprot.readFieldEnd()
14874 
    iprot.readStructEnd()
14875 
 
14876 
  def write(self, oprot):
14877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14879 
      return
14880 
    oprot.writeStructBegin('cancelInsurance_args')
14881 
    if self.cartId is not None:
14882 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14883 
      oprot.writeI64(self.cartId)
14884 
      oprot.writeFieldEnd()
14885 
    oprot.writeFieldStop()
14886 
    oprot.writeStructEnd()
14887 
 
14888 
  def validate(self):
14889 
    return
14890 
 
14891 
 
14892 
  def __repr__(self):
14893 
    L = ['%s=%r' % (key, value)
14894 
      for key, value in self.__dict__.iteritems()]
14895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14896 
 
14897 
  def __eq__(self, other):
14898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14899 
 
14900 
  def __ne__(self, other):
14901 
    return not (self == other)
14902 
 
14903 
class cancelInsurance_result:
14904 
  """
14905 
  Attributes:
14906 
   - success
14907 
  """
14908 
 
14909 
  thrift_spec = (
14910 
    (0, TType.BOOL, 'success', None, None, ), # 0
14911 
  )
14912 
 
14913 
  def __init__(self, success=None,):
14914 
    self.success = success
14915 
 
14916 
  def read(self, iprot):
14917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14919 
      return
14920 
    iprot.readStructBegin()
14921 
    while True:
14922 
      (fname, ftype, fid) = iprot.readFieldBegin()
14923 
      if ftype == TType.STOP:
14924 
        break
14925 
      if fid == 0:
14926 
        if ftype == TType.BOOL:
14927 
          self.success = iprot.readBool();
14928 
        else:
14929 
          iprot.skip(ftype)
14930 
      else:
14931 
        iprot.skip(ftype)
14932 
      iprot.readFieldEnd()
14933 
    iprot.readStructEnd()
14934 
 
14935 
  def write(self, oprot):
14936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14938 
      return
14939 
    oprot.writeStructBegin('cancelInsurance_result')
14940 
    if self.success is not None:
14941 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14942 
      oprot.writeBool(self.success)
14943 
      oprot.writeFieldEnd()
14944 
    oprot.writeFieldStop()
14945 
    oprot.writeStructEnd()
14946 
 
14947 
  def validate(self):
14948 
    return
14949 
 
14950 
 
14951 
  def __repr__(self):
14952 
    L = ['%s=%r' % (key, value)
14953 
      for key, value in self.__dict__.iteritems()]
14954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14955 
 
14956 
  def __eq__(self, other):
14957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14958 
 
14959 
  def __ne__(self, other):
14960 
    return not (self == other)
14961 
 
14962 
class storeInsuranceSpecificDetails_args:
14963 
  """
14964 
  Attributes:
14965 
   - addressId
14966 
   - dob
14967 
   - guardianName
14968 
  """
14969 
 
14970 
  thrift_spec = (
14971 
    None, # 0
14972 
    (1, TType.I64, 'addressId', None, None, ), # 1
14973 
    (2, TType.STRING, 'dob', None, None, ), # 2
14974 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14975 
  )
14976 
 
14977 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14978 
    self.addressId = addressId
14979 
    self.dob = dob
14980 
    self.guardianName = guardianName
14981 
 
14982 
  def read(self, iprot):
14983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14985 
      return
14986 
    iprot.readStructBegin()
14987 
    while True:
14988 
      (fname, ftype, fid) = iprot.readFieldBegin()
14989 
      if ftype == TType.STOP:
14990 
        break
14991 
      if fid == 1:
14992 
        if ftype == TType.I64:
14993 
          self.addressId = iprot.readI64();
14994 
        else:
14995 
          iprot.skip(ftype)
14996 
      elif fid == 2:
14997 
        if ftype == TType.STRING:
14998 
          self.dob = iprot.readString();
14999 
        else:
15000 
          iprot.skip(ftype)
15001 
      elif fid == 3:
15002 
        if ftype == TType.STRING:
15003 
          self.guardianName = iprot.readString();
15004 
        else:
15005 
          iprot.skip(ftype)
15006 
      else:
15007 
        iprot.skip(ftype)
15008 
      iprot.readFieldEnd()
15009 
    iprot.readStructEnd()
15010 
 
15011 
  def write(self, oprot):
15012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15014 
      return
15015 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
15016 
    if self.addressId is not None:
15017 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15018 
      oprot.writeI64(self.addressId)
15019 
      oprot.writeFieldEnd()
15020 
    if self.dob is not None:
15021 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
15022 
      oprot.writeString(self.dob)
15023 
      oprot.writeFieldEnd()
15024 
    if self.guardianName is not None:
15025 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
15026 
      oprot.writeString(self.guardianName)
15027 
      oprot.writeFieldEnd()
15028 
    oprot.writeFieldStop()
15029 
    oprot.writeStructEnd()
15030 
 
15031 
  def validate(self):
15032 
    return
15033 
 
15034 
 
15035 
  def __repr__(self):
15036 
    L = ['%s=%r' % (key, value)
15037 
      for key, value in self.__dict__.iteritems()]
15038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15039 
 
15040 
  def __eq__(self, other):
15041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15042 
 
15043 
  def __ne__(self, other):
15044 
    return not (self == other)
15045 
 
15046 
class storeInsuranceSpecificDetails_result:
15047 
  """
15048 
  Attributes:
15049 
   - success
15050 
  """
15051 
 
15052 
  thrift_spec = (
15053 
    (0, TType.BOOL, 'success', None, None, ), # 0
15054 
  )
15055 
 
15056 
  def __init__(self, success=None,):
15057 
    self.success = success
15058 
 
15059 
  def read(self, iprot):
15060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15062 
      return
15063 
    iprot.readStructBegin()
15064 
    while True:
15065 
      (fname, ftype, fid) = iprot.readFieldBegin()
15066 
      if ftype == TType.STOP:
15067 
        break
15068 
      if fid == 0:
15069 
        if ftype == TType.BOOL:
15070 
          self.success = iprot.readBool();
15071 
        else:
15072 
          iprot.skip(ftype)
15073 
      else:
15074 
        iprot.skip(ftype)
15075 
      iprot.readFieldEnd()
15076 
    iprot.readStructEnd()
15077 
 
15078 
  def write(self, oprot):
15079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15081 
      return
15082 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15083 
    if self.success is not None:
15084 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15085 
      oprot.writeBool(self.success)
15086 
      oprot.writeFieldEnd()
15087 
    oprot.writeFieldStop()
15088 
    oprot.writeStructEnd()
15089 
 
15090 
  def validate(self):
15091 
    return
15092 
 
15093 
 
15094 
  def __repr__(self):
15095 
    L = ['%s=%r' % (key, value)
15096 
      for key, value in self.__dict__.iteritems()]
15097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15098 
 
15099 
  def __eq__(self, other):
15100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15101 
 
15102 
  def __ne__(self, other):
15103 
    return not (self == other)
15104 
 
15105 
class isInsuranceDetailPresent_args:
15106 
  """
15107 
  Attributes:
15108 
   - addressId
15109 
  """
15110 
 
15111 
  thrift_spec = (
15112 
    None, # 0
15113 
    (1, TType.I64, 'addressId', None, None, ), # 1
15114 
  )
15115 
 
15116 
  def __init__(self, addressId=None,):
15117 
    self.addressId = addressId
15118 
 
15119 
  def read(self, iprot):
15120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15122 
      return
15123 
    iprot.readStructBegin()
15124 
    while True:
15125 
      (fname, ftype, fid) = iprot.readFieldBegin()
15126 
      if ftype == TType.STOP:
15127 
        break
15128 
      if fid == 1:
15129 
        if ftype == TType.I64:
15130 
          self.addressId = iprot.readI64();
15131 
        else:
15132 
          iprot.skip(ftype)
15133 
      else:
15134 
        iprot.skip(ftype)
15135 
      iprot.readFieldEnd()
15136 
    iprot.readStructEnd()
15137 
 
15138 
  def write(self, oprot):
15139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15141 
      return
15142 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15143 
    if self.addressId is not None:
15144 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15145 
      oprot.writeI64(self.addressId)
15146 
      oprot.writeFieldEnd()
15147 
    oprot.writeFieldStop()
15148 
    oprot.writeStructEnd()
15149 
 
15150 
  def validate(self):
15151 
    return
15152 
 
15153 
 
15154 
  def __repr__(self):
15155 
    L = ['%s=%r' % (key, value)
15156 
      for key, value in self.__dict__.iteritems()]
15157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15158 
 
15159 
  def __eq__(self, other):
15160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15161 
 
15162 
  def __ne__(self, other):
15163 
    return not (self == other)
15164 
 
15165 
class isInsuranceDetailPresent_result:
15166 
  """
15167 
  Attributes:
15168 
   - success
15169 
  """
15170 
 
15171 
  thrift_spec = (
15172 
    (0, TType.BOOL, 'success', None, None, ), # 0
15173 
  )
15174 
 
15175 
  def __init__(self, success=None,):
15176 
    self.success = success
15177 
 
15178 
  def read(self, iprot):
15179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15181 
      return
15182 
    iprot.readStructBegin()
15183 
    while True:
15184 
      (fname, ftype, fid) = iprot.readFieldBegin()
15185 
      if ftype == TType.STOP:
15186 
        break
15187 
      if fid == 0:
15188 
        if ftype == TType.BOOL:
15189 
          self.success = iprot.readBool();
15190 
        else:
15191 
          iprot.skip(ftype)
15192 
      else:
15193 
        iprot.skip(ftype)
15194 
      iprot.readFieldEnd()
15195 
    iprot.readStructEnd()
15196 
 
15197 
  def write(self, oprot):
15198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15200 
      return
15201 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15202 
    if self.success is not None:
15203 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15204 
      oprot.writeBool(self.success)
15205 
      oprot.writeFieldEnd()
15206 
    oprot.writeFieldStop()
15207 
    oprot.writeStructEnd()
15208 
 
15209 
  def validate(self):
15210 
    return
15211 
 
15212 
 
15213 
  def __repr__(self):
15214 
    L = ['%s=%r' % (key, value)
15215 
      for key, value in self.__dict__.iteritems()]
15216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15217 
 
15218 
  def __eq__(self, other):
15219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15220 
 
15221 
  def __ne__(self, other):
15222 
    return not (self == other)
15223 
 
9791 rajveer 15224 
class getProductsAddedToCart_args:
6821 amar.kumar 15225 
  """
15226 
  Attributes:
15227 
   - startDate
15228 
   - endDate
15229 
  """
15230 
 
15231 
  thrift_spec = (
15232 
    None, # 0
9791 rajveer 15233 
    (1, TType.I64, 'startDate', None, None, ), # 1
15234 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15235 
  )
15236 
 
9791 rajveer 15237 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15238 
    self.startDate = startDate
15239 
    self.endDate = endDate
15240 
 
15241 
  def read(self, iprot):
15242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15244 
      return
15245 
    iprot.readStructBegin()
15246 
    while True:
15247 
      (fname, ftype, fid) = iprot.readFieldBegin()
15248 
      if ftype == TType.STOP:
15249 
        break
15250 
      if fid == 1:
15251 
        if ftype == TType.I64:
9791 rajveer 15252 
          self.startDate = iprot.readI64();
6821 amar.kumar 15253 
        else:
15254 
          iprot.skip(ftype)
15255 
      elif fid == 2:
15256 
        if ftype == TType.I64:
15257 
          self.endDate = iprot.readI64();
15258 
        else:
15259 
          iprot.skip(ftype)
15260 
      else:
15261 
        iprot.skip(ftype)
15262 
      iprot.readFieldEnd()
15263 
    iprot.readStructEnd()
15264 
 
15265 
  def write(self, oprot):
15266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15268 
      return
9791 rajveer 15269 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15270 
    if self.startDate is not None:
9791 rajveer 15271 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15272 
      oprot.writeI64(self.startDate)
15273 
      oprot.writeFieldEnd()
15274 
    if self.endDate is not None:
9791 rajveer 15275 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15276 
      oprot.writeI64(self.endDate)
15277 
      oprot.writeFieldEnd()
15278 
    oprot.writeFieldStop()
15279 
    oprot.writeStructEnd()
15280 
 
15281 
  def validate(self):
15282 
    return
15283 
 
15284 
 
15285 
  def __repr__(self):
15286 
    L = ['%s=%r' % (key, value)
15287 
      for key, value in self.__dict__.iteritems()]
15288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15289 
 
15290 
  def __eq__(self, other):
15291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15292 
 
15293 
  def __ne__(self, other):
15294 
    return not (self == other)
15295 
 
9791 rajveer 15296 
class getProductsAddedToCart_result:
6821 amar.kumar 15297 
  """
15298 
  Attributes:
15299 
   - success
15300 
  """
15301 
 
15302 
  thrift_spec = (
9791 rajveer 15303 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15304 
  )
15305 
 
15306 
  def __init__(self, success=None,):
15307 
    self.success = success
15308 
 
15309 
  def read(self, iprot):
15310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15312 
      return
15313 
    iprot.readStructBegin()
15314 
    while True:
15315 
      (fname, ftype, fid) = iprot.readFieldBegin()
15316 
      if ftype == TType.STOP:
15317 
        break
15318 
      if fid == 0:
9791 rajveer 15319 
        if ftype == TType.LIST:
15320 
          self.success = []
11980 amit.gupta 15321 
          (_etype221, _size218) = iprot.readListBegin()
15322 
          for _i222 in xrange(_size218):
15323 
            _elem223 = iprot.readI64();
15324 
            self.success.append(_elem223)
9791 rajveer 15325 
          iprot.readListEnd()
6821 amar.kumar 15326 
        else:
15327 
          iprot.skip(ftype)
15328 
      else:
15329 
        iprot.skip(ftype)
15330 
      iprot.readFieldEnd()
15331 
    iprot.readStructEnd()
15332 
 
15333 
  def write(self, oprot):
15334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15336 
      return
9791 rajveer 15337 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15338 
    if self.success is not None:
9791 rajveer 15339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15340 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15341 
      for iter224 in self.success:
15342 
        oprot.writeI64(iter224)
9791 rajveer 15343 
      oprot.writeListEnd()
6821 amar.kumar 15344 
      oprot.writeFieldEnd()
15345 
    oprot.writeFieldStop()
15346 
    oprot.writeStructEnd()
15347 
 
15348 
  def validate(self):
15349 
    return
15350 
 
15351 
 
15352 
  def __repr__(self):
15353 
    L = ['%s=%r' % (key, value)
15354 
      for key, value in self.__dict__.iteritems()]
15355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15356 
 
15357 
  def __eq__(self, other):
15358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15359 
 
15360 
  def __ne__(self, other):
15361 
    return not (self == other)
11592 amit.gupta 15362 
 
15363 
class validateCartPlus_args:
15364 
  """
15365 
  Attributes:
15366 
   - cartId
15367 
   - sourceId
11980 amit.gupta 15368 
   - dealerCoupon
11592 amit.gupta 15369 
  """
15370 
 
15371 
  thrift_spec = (
15372 
    None, # 0
15373 
    (1, TType.I64, 'cartId', None, None, ), # 1
15374 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15375 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15376 
  )
15377 
 
11980 amit.gupta 15378 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15379 
    self.cartId = cartId
15380 
    self.sourceId = sourceId
11980 amit.gupta 15381 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15382 
 
15383 
  def read(self, iprot):
15384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15386 
      return
15387 
    iprot.readStructBegin()
15388 
    while True:
15389 
      (fname, ftype, fid) = iprot.readFieldBegin()
15390 
      if ftype == TType.STOP:
15391 
        break
15392 
      if fid == 1:
15393 
        if ftype == TType.I64:
15394 
          self.cartId = iprot.readI64();
15395 
        else:
15396 
          iprot.skip(ftype)
15397 
      elif fid == 2:
15398 
        if ftype == TType.I64:
15399 
          self.sourceId = iprot.readI64();
15400 
        else:
15401 
          iprot.skip(ftype)
11980 amit.gupta 15402 
      elif fid == 3:
15403 
        if ftype == TType.STRING:
15404 
          self.dealerCoupon = iprot.readString();
15405 
        else:
15406 
          iprot.skip(ftype)
11592 amit.gupta 15407 
      else:
15408 
        iprot.skip(ftype)
15409 
      iprot.readFieldEnd()
15410 
    iprot.readStructEnd()
15411 
 
15412 
  def write(self, oprot):
15413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15415 
      return
15416 
    oprot.writeStructBegin('validateCartPlus_args')
15417 
    if self.cartId is not None:
15418 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15419 
      oprot.writeI64(self.cartId)
15420 
      oprot.writeFieldEnd()
15421 
    if self.sourceId is not None:
15422 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15423 
      oprot.writeI64(self.sourceId)
15424 
      oprot.writeFieldEnd()
11980 amit.gupta 15425 
    if self.dealerCoupon is not None:
15426 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15427 
      oprot.writeString(self.dealerCoupon)
15428 
      oprot.writeFieldEnd()
11592 amit.gupta 15429 
    oprot.writeFieldStop()
15430 
    oprot.writeStructEnd()
15431 
 
15432 
  def validate(self):
15433 
    return
15434 
 
15435 
 
15436 
  def __repr__(self):
15437 
    L = ['%s=%r' % (key, value)
15438 
      for key, value in self.__dict__.iteritems()]
15439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15440 
 
15441 
  def __eq__(self, other):
15442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15443 
 
15444 
  def __ne__(self, other):
15445 
    return not (self == other)
15446 
 
15447 
class validateCartPlus_result:
15448 
  """
15449 
  Attributes:
15450 
   - success
15451 
   - scex
15452 
  """
15453 
 
15454 
  thrift_spec = (
15455 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15456 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15457 
  )
15458 
 
15459 
  def __init__(self, success=None, scex=None,):
15460 
    self.success = success
15461 
    self.scex = scex
15462 
 
15463 
  def read(self, iprot):
15464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15466 
      return
15467 
    iprot.readStructBegin()
15468 
    while True:
15469 
      (fname, ftype, fid) = iprot.readFieldBegin()
15470 
      if ftype == TType.STOP:
15471 
        break
15472 
      if fid == 0:
15473 
        if ftype == TType.STRUCT:
15474 
          self.success = CartPlus()
15475 
          self.success.read(iprot)
15476 
        else:
15477 
          iprot.skip(ftype)
15478 
      elif fid == 1:
15479 
        if ftype == TType.STRUCT:
15480 
          self.scex = ShoppingCartException()
15481 
          self.scex.read(iprot)
15482 
        else:
15483 
          iprot.skip(ftype)
15484 
      else:
15485 
        iprot.skip(ftype)
15486 
      iprot.readFieldEnd()
15487 
    iprot.readStructEnd()
15488 
 
15489 
  def write(self, oprot):
15490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15492 
      return
15493 
    oprot.writeStructBegin('validateCartPlus_result')
15494 
    if self.success is not None:
15495 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15496 
      self.success.write(oprot)
15497 
      oprot.writeFieldEnd()
15498 
    if self.scex is not None:
15499 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15500 
      self.scex.write(oprot)
15501 
      oprot.writeFieldEnd()
15502 
    oprot.writeFieldStop()
15503 
    oprot.writeStructEnd()
15504 
 
15505 
  def validate(self):
15506 
    return
15507 
 
15508 
 
15509 
  def __repr__(self):
15510 
    L = ['%s=%r' % (key, value)
15511 
      for key, value in self.__dict__.iteritems()]
15512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15513 
 
15514 
  def __eq__(self, other):
15515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15516 
 
15517 
  def __ne__(self, other):
15518 
    return not (self == other)
11679 vikram.rag 15519 
 
15520 
class isPrivateDealUser_args:
15521 
  """
15522 
  Attributes:
15523 
   - userId
15524 
  """
15525 
 
15526 
  thrift_spec = (
15527 
    None, # 0
15528 
    (1, TType.I64, 'userId', None, None, ), # 1
15529 
  )
15530 
 
15531 
  def __init__(self, userId=None,):
15532 
    self.userId = userId
15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 1:
15544 
        if ftype == TType.I64:
15545 
          self.userId = iprot.readI64();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('isPrivateDealUser_args')
15558 
    if self.userId is not None:
15559 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15560 
      oprot.writeI64(self.userId)
15561 
      oprot.writeFieldEnd()
15562 
    oprot.writeFieldStop()
15563 
    oprot.writeStructEnd()
15564 
 
15565 
  def validate(self):
15566 
    return
15567 
 
15568 
 
15569 
  def __repr__(self):
15570 
    L = ['%s=%r' % (key, value)
15571 
      for key, value in self.__dict__.iteritems()]
15572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15573 
 
15574 
  def __eq__(self, other):
15575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15576 
 
15577 
  def __ne__(self, other):
15578 
    return not (self == other)
15579 
 
15580 
class isPrivateDealUser_result:
15581 
  """
15582 
  Attributes:
15583 
   - success
15584 
  """
15585 
 
15586 
  thrift_spec = (
15587 
    (0, TType.BOOL, 'success', None, None, ), # 0
15588 
  )
15589 
 
15590 
  def __init__(self, success=None,):
15591 
    self.success = success
15592 
 
15593 
  def read(self, iprot):
15594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15596 
      return
15597 
    iprot.readStructBegin()
15598 
    while True:
15599 
      (fname, ftype, fid) = iprot.readFieldBegin()
15600 
      if ftype == TType.STOP:
15601 
        break
15602 
      if fid == 0:
15603 
        if ftype == TType.BOOL:
15604 
          self.success = iprot.readBool();
15605 
        else:
15606 
          iprot.skip(ftype)
15607 
      else:
15608 
        iprot.skip(ftype)
15609 
      iprot.readFieldEnd()
15610 
    iprot.readStructEnd()
15611 
 
15612 
  def write(self, oprot):
15613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15615 
      return
15616 
    oprot.writeStructBegin('isPrivateDealUser_result')
15617 
    if self.success is not None:
15618 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15619 
      oprot.writeBool(self.success)
15620 
      oprot.writeFieldEnd()
15621 
    oprot.writeFieldStop()
15622 
    oprot.writeStructEnd()
15623 
 
15624 
  def validate(self):
15625 
    return
15626 
 
15627 
 
15628 
  def __repr__(self):
15629 
    L = ['%s=%r' % (key, value)
15630 
      for key, value in self.__dict__.iteritems()]
15631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15632 
 
15633 
  def __eq__(self, other):
15634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15635 
 
15636 
  def __ne__(self, other):
15637 
    return not (self == other)
11890 kshitij.so 15638 
 
15639 
class addPrivateDealUser_args:
15640 
  """
15641 
  Attributes:
15642 
   - userId
15643 
  """
15644 
 
15645 
  thrift_spec = (
15646 
    None, # 0
15647 
    (1, TType.I64, 'userId', None, None, ), # 1
15648 
  )
15649 
 
15650 
  def __init__(self, userId=None,):
15651 
    self.userId = userId
15652 
 
15653 
  def read(self, iprot):
15654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15656 
      return
15657 
    iprot.readStructBegin()
15658 
    while True:
15659 
      (fname, ftype, fid) = iprot.readFieldBegin()
15660 
      if ftype == TType.STOP:
15661 
        break
15662 
      if fid == 1:
15663 
        if ftype == TType.I64:
15664 
          self.userId = iprot.readI64();
15665 
        else:
15666 
          iprot.skip(ftype)
15667 
      else:
15668 
        iprot.skip(ftype)
15669 
      iprot.readFieldEnd()
15670 
    iprot.readStructEnd()
15671 
 
15672 
  def write(self, oprot):
15673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15675 
      return
15676 
    oprot.writeStructBegin('addPrivateDealUser_args')
15677 
    if self.userId is not None:
15678 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15679 
      oprot.writeI64(self.userId)
15680 
      oprot.writeFieldEnd()
15681 
    oprot.writeFieldStop()
15682 
    oprot.writeStructEnd()
15683 
 
15684 
  def validate(self):
15685 
    return
15686 
 
15687 
 
15688 
  def __repr__(self):
15689 
    L = ['%s=%r' % (key, value)
15690 
      for key, value in self.__dict__.iteritems()]
15691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15692 
 
15693 
  def __eq__(self, other):
15694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15695 
 
15696 
  def __ne__(self, other):
15697 
    return not (self == other)
15698 
 
15699 
class addPrivateDealUser_result:
15700 
  """
15701 
  Attributes:
15702 
   - success
15703 
  """
15704 
 
15705 
  thrift_spec = (
15706 
    (0, TType.BOOL, 'success', None, None, ), # 0
15707 
  )
15708 
 
15709 
  def __init__(self, success=None,):
15710 
    self.success = success
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      if fid == 0:
15722 
        if ftype == TType.BOOL:
15723 
          self.success = iprot.readBool();
15724 
        else:
15725 
          iprot.skip(ftype)
15726 
      else:
15727 
        iprot.skip(ftype)
15728 
      iprot.readFieldEnd()
15729 
    iprot.readStructEnd()
15730 
 
15731 
  def write(self, oprot):
15732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15734 
      return
15735 
    oprot.writeStructBegin('addPrivateDealUser_result')
15736 
    if self.success is not None:
15737 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15738 
      oprot.writeBool(self.success)
15739 
      oprot.writeFieldEnd()
15740 
    oprot.writeFieldStop()
15741 
    oprot.writeStructEnd()
15742 
 
15743 
  def validate(self):
15744 
    return
15745 
 
15746 
 
15747 
  def __repr__(self):
15748 
    L = ['%s=%r' % (key, value)
15749 
      for key, value in self.__dict__.iteritems()]
15750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15751 
 
15752 
  def __eq__(self, other):
15753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15754 
 
15755 
  def __ne__(self, other):
15756 
    return not (self == other)
15757 
 
15758 
class changePrivateDealUserStatus_args:
15759 
  """
15760 
  Attributes:
15761 
   - userId
15762 
   - isActive
15763 
  """
15764 
 
15765 
  thrift_spec = (
15766 
    None, # 0
15767 
    (1, TType.I64, 'userId', None, None, ), # 1
15768 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15769 
  )
15770 
 
15771 
  def __init__(self, userId=None, isActive=None,):
15772 
    self.userId = userId
15773 
    self.isActive = isActive
15774 
 
15775 
  def read(self, iprot):
15776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15778 
      return
15779 
    iprot.readStructBegin()
15780 
    while True:
15781 
      (fname, ftype, fid) = iprot.readFieldBegin()
15782 
      if ftype == TType.STOP:
15783 
        break
15784 
      if fid == 1:
15785 
        if ftype == TType.I64:
15786 
          self.userId = iprot.readI64();
15787 
        else:
15788 
          iprot.skip(ftype)
15789 
      elif fid == 2:
15790 
        if ftype == TType.BOOL:
15791 
          self.isActive = iprot.readBool();
15792 
        else:
15793 
          iprot.skip(ftype)
15794 
      else:
15795 
        iprot.skip(ftype)
15796 
      iprot.readFieldEnd()
15797 
    iprot.readStructEnd()
15798 
 
15799 
  def write(self, oprot):
15800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15802 
      return
15803 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15804 
    if self.userId is not None:
15805 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15806 
      oprot.writeI64(self.userId)
15807 
      oprot.writeFieldEnd()
15808 
    if self.isActive is not None:
15809 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15810 
      oprot.writeBool(self.isActive)
15811 
      oprot.writeFieldEnd()
15812 
    oprot.writeFieldStop()
15813 
    oprot.writeStructEnd()
15814 
 
15815 
  def validate(self):
15816 
    return
15817 
 
15818 
 
15819 
  def __repr__(self):
15820 
    L = ['%s=%r' % (key, value)
15821 
      for key, value in self.__dict__.iteritems()]
15822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15823 
 
15824 
  def __eq__(self, other):
15825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15826 
 
15827 
  def __ne__(self, other):
15828 
    return not (self == other)
15829 
 
15830 
class changePrivateDealUserStatus_result:
15831 
  """
15832 
  Attributes:
15833 
   - success
15834 
  """
15835 
 
15836 
  thrift_spec = (
15837 
    (0, TType.BOOL, 'success', None, None, ), # 0
15838 
  )
15839 
 
15840 
  def __init__(self, success=None,):
15841 
    self.success = success
15842 
 
15843 
  def read(self, iprot):
15844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15846 
      return
15847 
    iprot.readStructBegin()
15848 
    while True:
15849 
      (fname, ftype, fid) = iprot.readFieldBegin()
15850 
      if ftype == TType.STOP:
15851 
        break
15852 
      if fid == 0:
15853 
        if ftype == TType.BOOL:
15854 
          self.success = iprot.readBool();
15855 
        else:
15856 
          iprot.skip(ftype)
15857 
      else:
15858 
        iprot.skip(ftype)
15859 
      iprot.readFieldEnd()
15860 
    iprot.readStructEnd()
15861 
 
15862 
  def write(self, oprot):
15863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15865 
      return
15866 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15867 
    if self.success is not None:
15868 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15869 
      oprot.writeBool(self.success)
15870 
      oprot.writeFieldEnd()
15871 
    oprot.writeFieldStop()
15872 
    oprot.writeStructEnd()
15873 
 
15874 
  def validate(self):
15875 
    return
15876 
 
15877 
 
15878 
  def __repr__(self):
15879 
    L = ['%s=%r' % (key, value)
15880 
      for key, value in self.__dict__.iteritems()]
15881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15882 
 
15883 
  def __eq__(self, other):
15884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15885 
 
15886 
  def __ne__(self, other):
15887 
    return not (self == other)
15888 
 
15889 
class getPrivateDealUser_args:
15890 
  """
15891 
  Attributes:
15892 
   - userId
15893 
  """
15894 
 
15895 
  thrift_spec = (
15896 
    None, # 0
15897 
    (1, TType.I64, 'userId', None, None, ), # 1
15898 
  )
15899 
 
15900 
  def __init__(self, userId=None,):
15901 
    self.userId = userId
15902 
 
15903 
  def read(self, iprot):
15904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15906 
      return
15907 
    iprot.readStructBegin()
15908 
    while True:
15909 
      (fname, ftype, fid) = iprot.readFieldBegin()
15910 
      if ftype == TType.STOP:
15911 
        break
15912 
      if fid == 1:
15913 
        if ftype == TType.I64:
15914 
          self.userId = iprot.readI64();
15915 
        else:
15916 
          iprot.skip(ftype)
15917 
      else:
15918 
        iprot.skip(ftype)
15919 
      iprot.readFieldEnd()
15920 
    iprot.readStructEnd()
15921 
 
15922 
  def write(self, oprot):
15923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15925 
      return
15926 
    oprot.writeStructBegin('getPrivateDealUser_args')
15927 
    if self.userId is not None:
15928 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15929 
      oprot.writeI64(self.userId)
15930 
      oprot.writeFieldEnd()
15931 
    oprot.writeFieldStop()
15932 
    oprot.writeStructEnd()
15933 
 
15934 
  def validate(self):
15935 
    return
15936 
 
15937 
 
15938 
  def __repr__(self):
15939 
    L = ['%s=%r' % (key, value)
15940 
      for key, value in self.__dict__.iteritems()]
15941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15942 
 
15943 
  def __eq__(self, other):
15944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15945 
 
15946 
  def __ne__(self, other):
15947 
    return not (self == other)
15948 
 
15949 
class getPrivateDealUser_result:
15950 
  """
15951 
  Attributes:
15952 
   - success
15953 
  """
15954 
 
15955 
  thrift_spec = (
15956 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15957 
  )
15958 
 
15959 
  def __init__(self, success=None,):
15960 
    self.success = success
15961 
 
15962 
  def read(self, iprot):
15963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15965 
      return
15966 
    iprot.readStructBegin()
15967 
    while True:
15968 
      (fname, ftype, fid) = iprot.readFieldBegin()
15969 
      if ftype == TType.STOP:
15970 
        break
15971 
      if fid == 0:
15972 
        if ftype == TType.STRUCT:
15973 
          self.success = PrivateDealUser()
15974 
          self.success.read(iprot)
15975 
        else:
15976 
          iprot.skip(ftype)
15977 
      else:
15978 
        iprot.skip(ftype)
15979 
      iprot.readFieldEnd()
15980 
    iprot.readStructEnd()
15981 
 
15982 
  def write(self, oprot):
15983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15985 
      return
15986 
    oprot.writeStructBegin('getPrivateDealUser_result')
15987 
    if self.success is not None:
15988 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15989 
      self.success.write(oprot)
15990 
      oprot.writeFieldEnd()
15991 
    oprot.writeFieldStop()
15992 
    oprot.writeStructEnd()
15993 
 
15994 
  def validate(self):
15995 
    return
15996 
 
15997 
 
15998 
  def __repr__(self):
15999 
    L = ['%s=%r' % (key, value)
16000 
      for key, value in self.__dict__.iteritems()]
16001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16002 
 
16003 
  def __eq__(self, other):
16004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16005 
 
16006 
  def __ne__(self, other):
16007 
    return not (self == other)
12696 amit.gupta 16008 
 
16009 
class registerCounter_args:
16010 
  """
16011 
  Attributes:
16012 
   - counter
16013 
   - userId
16014 
  """
16015 
 
16016 
  thrift_spec = (
16017 
    None, # 0
16018 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
16019 
    (2, TType.I64, 'userId', None, None, ), # 2
16020 
  )
16021 
 
16022 
  def __init__(self, counter=None, userId=None,):
16023 
    self.counter = counter
16024 
    self.userId = userId
16025 
 
16026 
  def read(self, iprot):
16027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16029 
      return
16030 
    iprot.readStructBegin()
16031 
    while True:
16032 
      (fname, ftype, fid) = iprot.readFieldBegin()
16033 
      if ftype == TType.STOP:
16034 
        break
16035 
      if fid == 1:
16036 
        if ftype == TType.STRUCT:
16037 
          self.counter = Counter()
16038 
          self.counter.read(iprot)
16039 
        else:
16040 
          iprot.skip(ftype)
16041 
      elif fid == 2:
16042 
        if ftype == TType.I64:
16043 
          self.userId = iprot.readI64();
16044 
        else:
16045 
          iprot.skip(ftype)
16046 
      else:
16047 
        iprot.skip(ftype)
16048 
      iprot.readFieldEnd()
16049 
    iprot.readStructEnd()
16050 
 
16051 
  def write(self, oprot):
16052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16054 
      return
16055 
    oprot.writeStructBegin('registerCounter_args')
16056 
    if self.counter is not None:
16057 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16058 
      self.counter.write(oprot)
16059 
      oprot.writeFieldEnd()
16060 
    if self.userId is not None:
16061 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16062 
      oprot.writeI64(self.userId)
16063 
      oprot.writeFieldEnd()
16064 
    oprot.writeFieldStop()
16065 
    oprot.writeStructEnd()
16066 
 
16067 
  def validate(self):
16068 
    return
16069 
 
16070 
 
16071 
  def __repr__(self):
16072 
    L = ['%s=%r' % (key, value)
16073 
      for key, value in self.__dict__.iteritems()]
16074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16075 
 
16076 
  def __eq__(self, other):
16077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16078 
 
16079 
  def __ne__(self, other):
16080 
    return not (self == other)
16081 
 
16082 
class registerCounter_result:
16083 
  """
16084 
  Attributes:
16085 
   - success
16086 
  """
16087 
 
16088 
  thrift_spec = (
16089 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16090 
  )
16091 
 
16092 
  def __init__(self, success=None,):
16093 
    self.success = success
16094 
 
16095 
  def read(self, iprot):
16096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16098 
      return
16099 
    iprot.readStructBegin()
16100 
    while True:
16101 
      (fname, ftype, fid) = iprot.readFieldBegin()
16102 
      if ftype == TType.STOP:
16103 
        break
16104 
      if fid == 0:
16105 
        if ftype == TType.MAP:
16106 
          self.success = {}
16107 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16108 
          for _i229 in xrange(_size225):
16109 
            _key230 = iprot.readString();
16110 
            _val231 = iprot.readString();
16111 
            self.success[_key230] = _val231
16112 
          iprot.readMapEnd()
16113 
        else:
16114 
          iprot.skip(ftype)
16115 
      else:
16116 
        iprot.skip(ftype)
16117 
      iprot.readFieldEnd()
16118 
    iprot.readStructEnd()
16119 
 
16120 
  def write(self, oprot):
16121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16123 
      return
16124 
    oprot.writeStructBegin('registerCounter_result')
16125 
    if self.success is not None:
16126 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16127 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16128 
      for kiter232,viter233 in self.success.items():
16129 
        oprot.writeString(kiter232)
16130 
        oprot.writeString(viter233)
16131 
      oprot.writeMapEnd()
16132 
      oprot.writeFieldEnd()
16133 
    oprot.writeFieldStop()
16134 
    oprot.writeStructEnd()
16135 
 
16136 
  def validate(self):
16137 
    return
16138 
 
16139 
 
16140 
  def __repr__(self):
16141 
    L = ['%s=%r' % (key, value)
16142 
      for key, value in self.__dict__.iteritems()]
16143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16144 
 
16145 
  def __eq__(self, other):
16146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16147 
 
16148 
  def __ne__(self, other):
16149 
    return not (self == other)
12722 amit.gupta 16150 
 
16151 
class searchCounter_args:
16152 
  """
16153 
  Attributes:
16154 
   - type1
16155 
   - searchString
16156 
  """
16157 
 
16158 
  thrift_spec = (
16159 
    None, # 0
16160 
    (1, TType.STRING, 'type1', None, None, ), # 1
16161 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16162 
  )
16163 
 
16164 
  def __init__(self, type1=None, searchString=None,):
16165 
    self.type1 = type1
16166 
    self.searchString = searchString
16167 
 
16168 
  def read(self, iprot):
16169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16171 
      return
16172 
    iprot.readStructBegin()
16173 
    while True:
16174 
      (fname, ftype, fid) = iprot.readFieldBegin()
16175 
      if ftype == TType.STOP:
16176 
        break
16177 
      if fid == 1:
16178 
        if ftype == TType.STRING:
16179 
          self.type1 = iprot.readString();
16180 
        else:
16181 
          iprot.skip(ftype)
16182 
      elif fid == 2:
16183 
        if ftype == TType.STRING:
16184 
          self.searchString = iprot.readString();
16185 
        else:
16186 
          iprot.skip(ftype)
16187 
      else:
16188 
        iprot.skip(ftype)
16189 
      iprot.readFieldEnd()
16190 
    iprot.readStructEnd()
16191 
 
16192 
  def write(self, oprot):
16193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16195 
      return
16196 
    oprot.writeStructBegin('searchCounter_args')
16197 
    if self.type1 is not None:
16198 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16199 
      oprot.writeString(self.type1)
16200 
      oprot.writeFieldEnd()
16201 
    if self.searchString is not None:
16202 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16203 
      oprot.writeString(self.searchString)
16204 
      oprot.writeFieldEnd()
16205 
    oprot.writeFieldStop()
16206 
    oprot.writeStructEnd()
16207 
 
16208 
  def validate(self):
16209 
    return
16210 
 
16211 
 
16212 
  def __repr__(self):
16213 
    L = ['%s=%r' % (key, value)
16214 
      for key, value in self.__dict__.iteritems()]
16215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16216 
 
16217 
  def __eq__(self, other):
16218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16219 
 
16220 
  def __ne__(self, other):
16221 
    return not (self == other)
16222 
 
16223 
class searchCounter_result:
16224 
  """
16225 
  Attributes:
16226 
   - success
16227 
  """
16228 
 
16229 
  thrift_spec = (
16230 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16231 
  )
16232 
 
16233 
  def __init__(self, success=None,):
16234 
    self.success = success
16235 
 
16236 
  def read(self, iprot):
16237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16239 
      return
16240 
    iprot.readStructBegin()
16241 
    while True:
16242 
      (fname, ftype, fid) = iprot.readFieldBegin()
16243 
      if ftype == TType.STOP:
16244 
        break
16245 
      if fid == 0:
16246 
        if ftype == TType.LIST:
16247 
          self.success = []
16248 
          (_etype237, _size234) = iprot.readListBegin()
16249 
          for _i238 in xrange(_size234):
16250 
            _elem239 = Counter()
16251 
            _elem239.read(iprot)
16252 
            self.success.append(_elem239)
16253 
          iprot.readListEnd()
16254 
        else:
16255 
          iprot.skip(ftype)
16256 
      else:
16257 
        iprot.skip(ftype)
16258 
      iprot.readFieldEnd()
16259 
    iprot.readStructEnd()
16260 
 
16261 
  def write(self, oprot):
16262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16264 
      return
16265 
    oprot.writeStructBegin('searchCounter_result')
16266 
    if self.success is not None:
16267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16268 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16269 
      for iter240 in self.success:
16270 
        iter240.write(oprot)
16271 
      oprot.writeListEnd()
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
18977 amit.gupta 16291 
class getCounterByUserId_args:
16292 
  """
16293 
  Attributes:
16294 
   - userId
16295 
  """
16296 
 
16297 
  thrift_spec = (
16298 
    None, # 0
16299 
    (1, TType.I64, 'userId', None, None, ), # 1
16300 
  )
16301 
 
16302 
  def __init__(self, userId=None,):
16303 
    self.userId = userId
16304 
 
16305 
  def read(self, iprot):
16306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16308 
      return
16309 
    iprot.readStructBegin()
16310 
    while True:
16311 
      (fname, ftype, fid) = iprot.readFieldBegin()
16312 
      if ftype == TType.STOP:
16313 
        break
16314 
      if fid == 1:
16315 
        if ftype == TType.I64:
16316 
          self.userId = iprot.readI64();
16317 
        else:
16318 
          iprot.skip(ftype)
16319 
      else:
16320 
        iprot.skip(ftype)
16321 
      iprot.readFieldEnd()
16322 
    iprot.readStructEnd()
16323 
 
16324 
  def write(self, oprot):
16325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16327 
      return
16328 
    oprot.writeStructBegin('getCounterByUserId_args')
16329 
    if self.userId is not None:
16330 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16331 
      oprot.writeI64(self.userId)
16332 
      oprot.writeFieldEnd()
16333 
    oprot.writeFieldStop()
16334 
    oprot.writeStructEnd()
16335 
 
16336 
  def validate(self):
16337 
    return
16338 
 
16339 
 
16340 
  def __repr__(self):
16341 
    L = ['%s=%r' % (key, value)
16342 
      for key, value in self.__dict__.iteritems()]
16343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16344 
 
16345 
  def __eq__(self, other):
16346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16347 
 
16348 
  def __ne__(self, other):
16349 
    return not (self == other)
16350 
 
16351 
class getCounterByUserId_result:
16352 
  """
16353 
  Attributes:
16354 
   - success
16355 
  """
16356 
 
16357 
  thrift_spec = (
16358 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16359 
  )
16360 
 
16361 
  def __init__(self, success=None,):
16362 
    self.success = success
16363 
 
16364 
  def read(self, iprot):
16365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16367 
      return
16368 
    iprot.readStructBegin()
16369 
    while True:
16370 
      (fname, ftype, fid) = iprot.readFieldBegin()
16371 
      if ftype == TType.STOP:
16372 
        break
16373 
      if fid == 0:
16374 
        if ftype == TType.STRUCT:
16375 
          self.success = Counter()
16376 
          self.success.read(iprot)
16377 
        else:
16378 
          iprot.skip(ftype)
16379 
      else:
16380 
        iprot.skip(ftype)
16381 
      iprot.readFieldEnd()
16382 
    iprot.readStructEnd()
16383 
 
16384 
  def write(self, oprot):
16385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16387 
      return
16388 
    oprot.writeStructBegin('getCounterByUserId_result')
16389 
    if self.success is not None:
16390 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16391 
      self.success.write(oprot)
16392 
      oprot.writeFieldEnd()
16393 
    oprot.writeFieldStop()
16394 
    oprot.writeStructEnd()
16395 
 
16396 
  def validate(self):
16397 
    return
16398 
 
16399 
 
16400 
  def __repr__(self):
16401 
    L = ['%s=%r' % (key, value)
16402 
      for key, value in self.__dict__.iteritems()]
16403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16404 
 
16405 
  def __eq__(self, other):
16406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16407 
 
16408 
  def __ne__(self, other):
16409 
    return not (self == other)
16410 
 
12722 amit.gupta 16411 
class getAllUsersByCounter_args:
16412 
  """
16413 
  Attributes:
16414 
   - counterId
16415 
  """
16416 
 
16417 
  thrift_spec = (
16418 
    None, # 0
16419 
    (1, TType.I64, 'counterId', None, None, ), # 1
16420 
  )
16421 
 
16422 
  def __init__(self, counterId=None,):
16423 
    self.counterId = counterId
16424 
 
16425 
  def read(self, iprot):
16426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16428 
      return
16429 
    iprot.readStructBegin()
16430 
    while True:
16431 
      (fname, ftype, fid) = iprot.readFieldBegin()
16432 
      if ftype == TType.STOP:
16433 
        break
16434 
      if fid == 1:
16435 
        if ftype == TType.I64:
16436 
          self.counterId = iprot.readI64();
16437 
        else:
16438 
          iprot.skip(ftype)
16439 
      else:
16440 
        iprot.skip(ftype)
16441 
      iprot.readFieldEnd()
16442 
    iprot.readStructEnd()
16443 
 
16444 
  def write(self, oprot):
16445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16447 
      return
16448 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16449 
    if self.counterId is not None:
16450 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16451 
      oprot.writeI64(self.counterId)
16452 
      oprot.writeFieldEnd()
16453 
    oprot.writeFieldStop()
16454 
    oprot.writeStructEnd()
16455 
 
16456 
  def validate(self):
16457 
    return
16458 
 
16459 
 
16460 
  def __repr__(self):
16461 
    L = ['%s=%r' % (key, value)
16462 
      for key, value in self.__dict__.iteritems()]
16463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16464 
 
16465 
  def __eq__(self, other):
16466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16467 
 
16468 
  def __ne__(self, other):
16469 
    return not (self == other)
16470 
 
16471 
class getAllUsersByCounter_result:
16472 
  """
16473 
  Attributes:
16474 
   - success
16475 
  """
16476 
 
16477 
  thrift_spec = (
16478 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16479 
  )
16480 
 
16481 
  def __init__(self, success=None,):
16482 
    self.success = success
16483 
 
16484 
  def read(self, iprot):
16485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16487 
      return
16488 
    iprot.readStructBegin()
16489 
    while True:
16490 
      (fname, ftype, fid) = iprot.readFieldBegin()
16491 
      if ftype == TType.STOP:
16492 
        break
16493 
      if fid == 0:
16494 
        if ftype == TType.LIST:
16495 
          self.success = []
16496 
          (_etype244, _size241) = iprot.readListBegin()
16497 
          for _i245 in xrange(_size241):
16498 
            _elem246 = User()
16499 
            _elem246.read(iprot)
16500 
            self.success.append(_elem246)
16501 
          iprot.readListEnd()
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      else:
16505 
        iprot.skip(ftype)
16506 
      iprot.readFieldEnd()
16507 
    iprot.readStructEnd()
16508 
 
16509 
  def write(self, oprot):
16510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16512 
      return
16513 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16514 
    if self.success is not None:
16515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16517 
      for iter247 in self.success:
16518 
        iter247.write(oprot)
16519 
      oprot.writeListEnd()
16520 
      oprot.writeFieldEnd()
16521 
    oprot.writeFieldStop()
16522 
    oprot.writeStructEnd()
16523 
 
16524 
  def validate(self):
16525 
    return
16526 
 
16527 
 
16528 
  def __repr__(self):
16529 
    L = ['%s=%r' % (key, value)
16530 
      for key, value in self.__dict__.iteritems()]
16531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16532 
 
16533 
  def __eq__(self, other):
16534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16535 
 
16536 
  def __ne__(self, other):
16537 
    return not (self == other)
15251 manish.sha 16538 
 
16539 
class getActiveAccessTokenForUser_args:
16540 
  """
16541 
  Attributes:
16542 
   - userId
16543 
   - source
16544 
  """
16545 
 
16546 
  thrift_spec = (
16547 
    None, # 0
16548 
    (1, TType.I64, 'userId', None, None, ), # 1
16549 
    (2, TType.STRING, 'source', None, None, ), # 2
16550 
  )
16551 
 
16552 
  def __init__(self, userId=None, source=None,):
16553 
    self.userId = userId
16554 
    self.source = source
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 1:
16566 
        if ftype == TType.I64:
16567 
          self.userId = iprot.readI64();
16568 
        else:
16569 
          iprot.skip(ftype)
16570 
      elif fid == 2:
16571 
        if ftype == TType.STRING:
16572 
          self.source = iprot.readString();
16573 
        else:
16574 
          iprot.skip(ftype)
16575 
      else:
16576 
        iprot.skip(ftype)
16577 
      iprot.readFieldEnd()
16578 
    iprot.readStructEnd()
16579 
 
16580 
  def write(self, oprot):
16581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16583 
      return
16584 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16585 
    if self.userId is not None:
16586 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16587 
      oprot.writeI64(self.userId)
16588 
      oprot.writeFieldEnd()
16589 
    if self.source is not None:
16590 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16591 
      oprot.writeString(self.source)
16592 
      oprot.writeFieldEnd()
16593 
    oprot.writeFieldStop()
16594 
    oprot.writeStructEnd()
16595 
 
16596 
  def validate(self):
16597 
    return
16598 
 
16599 
 
16600 
  def __repr__(self):
16601 
    L = ['%s=%r' % (key, value)
16602 
      for key, value in self.__dict__.iteritems()]
16603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16604 
 
16605 
  def __eq__(self, other):
16606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16607 
 
16608 
  def __ne__(self, other):
16609 
    return not (self == other)
16610 
 
16611 
class getActiveAccessTokenForUser_result:
16612 
  """
16613 
  Attributes:
16614 
   - success
16615 
  """
16616 
 
16617 
  thrift_spec = (
16618 
    (0, TType.STRING, 'success', None, None, ), # 0
16619 
  )
16620 
 
16621 
  def __init__(self, success=None,):
16622 
    self.success = success
16623 
 
16624 
  def read(self, iprot):
16625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16627 
      return
16628 
    iprot.readStructBegin()
16629 
    while True:
16630 
      (fname, ftype, fid) = iprot.readFieldBegin()
16631 
      if ftype == TType.STOP:
16632 
        break
16633 
      if fid == 0:
16634 
        if ftype == TType.STRING:
16635 
          self.success = iprot.readString();
16636 
        else:
16637 
          iprot.skip(ftype)
16638 
      else:
16639 
        iprot.skip(ftype)
16640 
      iprot.readFieldEnd()
16641 
    iprot.readStructEnd()
16642 
 
16643 
  def write(self, oprot):
16644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16646 
      return
16647 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16648 
    if self.success is not None:
16649 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16650 
      oprot.writeString(self.success)
16651 
      oprot.writeFieldEnd()
16652 
    oprot.writeFieldStop()
16653 
    oprot.writeStructEnd()
16654 
 
16655 
  def validate(self):
16656 
    return
16657 
 
16658 
 
16659 
  def __repr__(self):
16660 
    L = ['%s=%r' % (key, value)
16661 
      for key, value in self.__dict__.iteritems()]
16662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16663 
 
16664 
  def __eq__(self, other):
16665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16666 
 
16667 
  def __ne__(self, other):
16668 
    return not (self == other)
16669 
 
16670 
class validateAccessToken_args:
16671 
  """
16672 
  Attributes:
16673 
   - accessToken
16674 
  """
16675 
 
16676 
  thrift_spec = (
16677 
    None, # 0
16678 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16679 
  )
16680 
 
16681 
  def __init__(self, accessToken=None,):
16682 
    self.accessToken = accessToken
16683 
 
16684 
  def read(self, iprot):
16685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16687 
      return
16688 
    iprot.readStructBegin()
16689 
    while True:
16690 
      (fname, ftype, fid) = iprot.readFieldBegin()
16691 
      if ftype == TType.STOP:
16692 
        break
16693 
      if fid == 1:
16694 
        if ftype == TType.STRING:
16695 
          self.accessToken = iprot.readString();
16696 
        else:
16697 
          iprot.skip(ftype)
16698 
      else:
16699 
        iprot.skip(ftype)
16700 
      iprot.readFieldEnd()
16701 
    iprot.readStructEnd()
16702 
 
16703 
  def write(self, oprot):
16704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16706 
      return
16707 
    oprot.writeStructBegin('validateAccessToken_args')
16708 
    if self.accessToken is not None:
16709 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16710 
      oprot.writeString(self.accessToken)
16711 
      oprot.writeFieldEnd()
16712 
    oprot.writeFieldStop()
16713 
    oprot.writeStructEnd()
16714 
 
16715 
  def validate(self):
16716 
    return
16717 
 
16718 
 
16719 
  def __repr__(self):
16720 
    L = ['%s=%r' % (key, value)
16721 
      for key, value in self.__dict__.iteritems()]
16722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16723 
 
16724 
  def __eq__(self, other):
16725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16726 
 
16727 
  def __ne__(self, other):
16728 
    return not (self == other)
16729 
 
16730 
class validateAccessToken_result:
16731 
  """
16732 
  Attributes:
16733 
   - success
16734 
  """
16735 
 
16736 
  thrift_spec = (
16737 
    (0, TType.BOOL, 'success', None, None, ), # 0
16738 
  )
16739 
 
16740 
  def __init__(self, success=None,):
16741 
    self.success = success
16742 
 
16743 
  def read(self, iprot):
16744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16746 
      return
16747 
    iprot.readStructBegin()
16748 
    while True:
16749 
      (fname, ftype, fid) = iprot.readFieldBegin()
16750 
      if ftype == TType.STOP:
16751 
        break
16752 
      if fid == 0:
16753 
        if ftype == TType.BOOL:
16754 
          self.success = iprot.readBool();
16755 
        else:
16756 
          iprot.skip(ftype)
16757 
      else:
16758 
        iprot.skip(ftype)
16759 
      iprot.readFieldEnd()
16760 
    iprot.readStructEnd()
16761 
 
16762 
  def write(self, oprot):
16763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16765 
      return
16766 
    oprot.writeStructBegin('validateAccessToken_result')
16767 
    if self.success is not None:
16768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16769 
      oprot.writeBool(self.success)
16770 
      oprot.writeFieldEnd()
16771 
    oprot.writeFieldStop()
16772 
    oprot.writeStructEnd()
16773 
 
16774 
  def validate(self):
16775 
    return
16776 
 
16777 
 
16778 
  def __repr__(self):
16779 
    L = ['%s=%r' % (key, value)
16780 
      for key, value in self.__dict__.iteritems()]
16781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16782 
 
16783 
  def __eq__(self, other):
16784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16785 
 
16786 
  def __ne__(self, other):
16787 
    return not (self == other)
17782 amit.gupta 16788 
 
16789 
class addItemsToCart_args:
16790 
  """
16791 
  Attributes:
16792 
   - cartId
16793 
   - itemQty
16794 
   - couponCode
16795 
  """
16796 
 
16797 
  thrift_spec = (
16798 
    None, # 0
16799 
    (1, TType.I64, 'cartId', None, None, ), # 1
16800 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16801 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16802 
  )
16803 
 
16804 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16805 
    self.cartId = cartId
16806 
    self.itemQty = itemQty
16807 
    self.couponCode = couponCode
16808 
 
16809 
  def read(self, iprot):
16810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16812 
      return
16813 
    iprot.readStructBegin()
16814 
    while True:
16815 
      (fname, ftype, fid) = iprot.readFieldBegin()
16816 
      if ftype == TType.STOP:
16817 
        break
16818 
      if fid == 1:
16819 
        if ftype == TType.I64:
16820 
          self.cartId = iprot.readI64();
16821 
        else:
16822 
          iprot.skip(ftype)
16823 
      elif fid == 2:
16824 
        if ftype == TType.LIST:
16825 
          self.itemQty = []
16826 
          (_etype251, _size248) = iprot.readListBegin()
16827 
          for _i252 in xrange(_size248):
16828 
            _elem253 = ItemQuantity()
16829 
            _elem253.read(iprot)
16830 
            self.itemQty.append(_elem253)
16831 
          iprot.readListEnd()
16832 
        else:
16833 
          iprot.skip(ftype)
16834 
      elif fid == 3:
16835 
        if ftype == TType.STRING:
16836 
          self.couponCode = iprot.readString();
16837 
        else:
16838 
          iprot.skip(ftype)
16839 
      else:
16840 
        iprot.skip(ftype)
16841 
      iprot.readFieldEnd()
16842 
    iprot.readStructEnd()
16843 
 
16844 
  def write(self, oprot):
16845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16847 
      return
16848 
    oprot.writeStructBegin('addItemsToCart_args')
16849 
    if self.cartId is not None:
16850 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16851 
      oprot.writeI64(self.cartId)
16852 
      oprot.writeFieldEnd()
16853 
    if self.itemQty is not None:
16854 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16855 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16856 
      for iter254 in self.itemQty:
16857 
        iter254.write(oprot)
16858 
      oprot.writeListEnd()
16859 
      oprot.writeFieldEnd()
16860 
    if self.couponCode is not None:
16861 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16862 
      oprot.writeString(self.couponCode)
16863 
      oprot.writeFieldEnd()
16864 
    oprot.writeFieldStop()
16865 
    oprot.writeStructEnd()
16866 
 
16867 
  def validate(self):
16868 
    return
16869 
 
16870 
 
16871 
  def __repr__(self):
16872 
    L = ['%s=%r' % (key, value)
16873 
      for key, value in self.__dict__.iteritems()]
16874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16875 
 
16876 
  def __eq__(self, other):
16877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16878 
 
16879 
  def __ne__(self, other):
16880 
    return not (self == other)
16881 
 
16882 
class addItemsToCart_result:
16883 
  """
16884 
  Attributes:
16885 
   - success
16886 
  """
16887 
 
16888 
  thrift_spec = (
16889 
    (0, TType.BOOL, 'success', None, None, ), # 0
16890 
  )
16891 
 
16892 
  def __init__(self, success=None,):
16893 
    self.success = success
16894 
 
16895 
  def read(self, iprot):
16896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16898 
      return
16899 
    iprot.readStructBegin()
16900 
    while True:
16901 
      (fname, ftype, fid) = iprot.readFieldBegin()
16902 
      if ftype == TType.STOP:
16903 
        break
16904 
      if fid == 0:
16905 
        if ftype == TType.BOOL:
16906 
          self.success = iprot.readBool();
16907 
        else:
16908 
          iprot.skip(ftype)
16909 
      else:
16910 
        iprot.skip(ftype)
16911 
      iprot.readFieldEnd()
16912 
    iprot.readStructEnd()
16913 
 
16914 
  def write(self, oprot):
16915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16917 
      return
16918 
    oprot.writeStructBegin('addItemsToCart_result')
16919 
    if self.success is not None:
16920 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16921 
      oprot.writeBool(self.success)
16922 
      oprot.writeFieldEnd()
16923 
    oprot.writeFieldStop()
16924 
    oprot.writeStructEnd()
16925 
 
16926 
  def validate(self):
16927 
    return
16928 
 
16929 
 
16930 
  def __repr__(self):
16931 
    L = ['%s=%r' % (key, value)
16932 
      for key, value in self.__dict__.iteritems()]
16933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16934 
 
16935 
  def __eq__(self, other):
16936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16937 
 
16938 
  def __ne__(self, other):
16939 
    return not (self == other)
16940 
 
16941 
class validateCartNew_args:
16942 
  """
16943 
  Attributes:
16944 
   - cartId
16945 
   - pinCode
16946 
   - sourceId
16947 
  """
16948 
 
16949 
  thrift_spec = (
16950 
    None, # 0
16951 
    (1, TType.I64, 'cartId', None, None, ), # 1
16952 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16953 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16954 
  )
16955 
 
16956 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16957 
    self.cartId = cartId
16958 
    self.pinCode = pinCode
16959 
    self.sourceId = sourceId
16960 
 
16961 
  def read(self, iprot):
16962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16964 
      return
16965 
    iprot.readStructBegin()
16966 
    while True:
16967 
      (fname, ftype, fid) = iprot.readFieldBegin()
16968 
      if ftype == TType.STOP:
16969 
        break
16970 
      if fid == 1:
16971 
        if ftype == TType.I64:
16972 
          self.cartId = iprot.readI64();
16973 
        else:
16974 
          iprot.skip(ftype)
16975 
      elif fid == 2:
16976 
        if ftype == TType.STRING:
16977 
          self.pinCode = iprot.readString();
16978 
        else:
16979 
          iprot.skip(ftype)
16980 
      elif fid == 3:
16981 
        if ftype == TType.I64:
16982 
          self.sourceId = iprot.readI64();
16983 
        else:
16984 
          iprot.skip(ftype)
16985 
      else:
16986 
        iprot.skip(ftype)
16987 
      iprot.readFieldEnd()
16988 
    iprot.readStructEnd()
16989 
 
16990 
  def write(self, oprot):
16991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16993 
      return
16994 
    oprot.writeStructBegin('validateCartNew_args')
16995 
    if self.cartId is not None:
16996 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16997 
      oprot.writeI64(self.cartId)
16998 
      oprot.writeFieldEnd()
16999 
    if self.pinCode is not None:
17000 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
17001 
      oprot.writeString(self.pinCode)
17002 
      oprot.writeFieldEnd()
17003 
    if self.sourceId is not None:
17004 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
17005 
      oprot.writeI64(self.sourceId)
17006 
      oprot.writeFieldEnd()
17007 
    oprot.writeFieldStop()
17008 
    oprot.writeStructEnd()
17009 
 
17010 
  def validate(self):
17011 
    return
17012 
 
17013 
 
17014 
  def __repr__(self):
17015 
    L = ['%s=%r' % (key, value)
17016 
      for key, value in self.__dict__.iteritems()]
17017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17018 
 
17019 
  def __eq__(self, other):
17020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17021 
 
17022 
  def __ne__(self, other):
17023 
    return not (self == other)
17024 
 
17025 
class validateCartNew_result:
17026 
  """
17027 
  Attributes:
17028 
   - success
17029 
  """
17030 
 
17031 
  thrift_spec = (
17032 
    (0, TType.STRING, 'success', None, None, ), # 0
17033 
  )
17034 
 
17035 
  def __init__(self, success=None,):
17036 
    self.success = success
17037 
 
17038 
  def read(self, iprot):
17039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17041 
      return
17042 
    iprot.readStructBegin()
17043 
    while True:
17044 
      (fname, ftype, fid) = iprot.readFieldBegin()
17045 
      if ftype == TType.STOP:
17046 
        break
17047 
      if fid == 0:
17048 
        if ftype == TType.STRING:
17049 
          self.success = iprot.readString();
17050 
        else:
17051 
          iprot.skip(ftype)
17052 
      else:
17053 
        iprot.skip(ftype)
17054 
      iprot.readFieldEnd()
17055 
    iprot.readStructEnd()
17056 
 
17057 
  def write(self, oprot):
17058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17060 
      return
17061 
    oprot.writeStructBegin('validateCartNew_result')
17062 
    if self.success is not None:
17063 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17064 
      oprot.writeString(self.success)
17065 
      oprot.writeFieldEnd()
17066 
    oprot.writeFieldStop()
17067 
    oprot.writeStructEnd()
17068 
 
17069 
  def validate(self):
17070 
    return
17071 
 
17072 
 
17073 
  def __repr__(self):
17074 
    L = ['%s=%r' % (key, value)
17075 
      for key, value in self.__dict__.iteritems()]
17076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17077 
 
17078 
  def __eq__(self, other):
17079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17080 
 
17081 
  def __ne__(self, other):
17082 
    return not (self == other)
18530 manish.sha 17083 
 
18644 manish.sha 17084 
class isAddressEditableForCounter_args:
18530 manish.sha 17085 
  """
17086 
  Attributes:
17087 
   - userId
17088 
  """
17089 
 
17090 
  thrift_spec = (
17091 
    None, # 0
17092 
    (1, TType.I64, 'userId', None, None, ), # 1
17093 
  )
17094 
 
17095 
  def __init__(self, userId=None,):
17096 
    self.userId = userId
17097 
 
17098 
  def read(self, iprot):
17099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17101 
      return
17102 
    iprot.readStructBegin()
17103 
    while True:
17104 
      (fname, ftype, fid) = iprot.readFieldBegin()
17105 
      if ftype == TType.STOP:
17106 
        break
17107 
      if fid == 1:
17108 
        if ftype == TType.I64:
17109 
          self.userId = iprot.readI64();
17110 
        else:
17111 
          iprot.skip(ftype)
17112 
      else:
17113 
        iprot.skip(ftype)
17114 
      iprot.readFieldEnd()
17115 
    iprot.readStructEnd()
17116 
 
17117 
  def write(self, oprot):
17118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17120 
      return
18644 manish.sha 17121 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17122 
    if self.userId is not None:
17123 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17124 
      oprot.writeI64(self.userId)
17125 
      oprot.writeFieldEnd()
17126 
    oprot.writeFieldStop()
17127 
    oprot.writeStructEnd()
17128 
 
17129 
  def validate(self):
17130 
    return
17131 
 
17132 
 
17133 
  def __repr__(self):
17134 
    L = ['%s=%r' % (key, value)
17135 
      for key, value in self.__dict__.iteritems()]
17136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17137 
 
17138 
  def __eq__(self, other):
17139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17140 
 
17141 
  def __ne__(self, other):
17142 
    return not (self == other)
17143 
 
18644 manish.sha 17144 
class isAddressEditableForCounter_result:
18530 manish.sha 17145 
  """
17146 
  Attributes:
17147 
   - success
17148 
  """
17149 
 
17150 
  thrift_spec = (
17151 
    (0, TType.BOOL, 'success', None, None, ), # 0
17152 
  )
17153 
 
17154 
  def __init__(self, success=None,):
17155 
    self.success = success
17156 
 
17157 
  def read(self, iprot):
17158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17160 
      return
17161 
    iprot.readStructBegin()
17162 
    while True:
17163 
      (fname, ftype, fid) = iprot.readFieldBegin()
17164 
      if ftype == TType.STOP:
17165 
        break
17166 
      if fid == 0:
17167 
        if ftype == TType.BOOL:
17168 
          self.success = iprot.readBool();
17169 
        else:
17170 
          iprot.skip(ftype)
17171 
      else:
17172 
        iprot.skip(ftype)
17173 
      iprot.readFieldEnd()
17174 
    iprot.readStructEnd()
17175 
 
17176 
  def write(self, oprot):
17177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17179 
      return
18644 manish.sha 17180 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17181 
    if self.success is not None:
17182 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17183 
      oprot.writeBool(self.success)
17184 
      oprot.writeFieldEnd()
17185 
    oprot.writeFieldStop()
17186 
    oprot.writeStructEnd()
17187 
 
17188 
  def validate(self):
17189 
    return
17190 
 
17191 
 
17192 
  def __repr__(self):
17193 
    L = ['%s=%r' % (key, value)
17194 
      for key, value in self.__dict__.iteritems()]
17195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17196 
 
17197 
  def __eq__(self, other):
17198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17199 
 
17200 
  def __ne__(self, other):
17201 
    return not (self == other)
17202 
 
17203 
class getBillingAddressForUser_args:
17204 
  """
17205 
  Attributes:
17206 
   - userId
17207 
  """
17208 
 
17209 
  thrift_spec = (
17210 
    None, # 0
17211 
    (1, TType.I64, 'userId', None, None, ), # 1
17212 
  )
17213 
 
17214 
  def __init__(self, userId=None,):
17215 
    self.userId = userId
17216 
 
17217 
  def read(self, iprot):
17218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17220 
      return
17221 
    iprot.readStructBegin()
17222 
    while True:
17223 
      (fname, ftype, fid) = iprot.readFieldBegin()
17224 
      if ftype == TType.STOP:
17225 
        break
17226 
      if fid == 1:
17227 
        if ftype == TType.I64:
17228 
          self.userId = iprot.readI64();
17229 
        else:
17230 
          iprot.skip(ftype)
17231 
      else:
17232 
        iprot.skip(ftype)
17233 
      iprot.readFieldEnd()
17234 
    iprot.readStructEnd()
17235 
 
17236 
  def write(self, oprot):
17237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17239 
      return
17240 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17241 
    if self.userId is not None:
17242 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17243 
      oprot.writeI64(self.userId)
17244 
      oprot.writeFieldEnd()
17245 
    oprot.writeFieldStop()
17246 
    oprot.writeStructEnd()
17247 
 
17248 
  def validate(self):
17249 
    return
17250 
 
17251 
 
17252 
  def __repr__(self):
17253 
    L = ['%s=%r' % (key, value)
17254 
      for key, value in self.__dict__.iteritems()]
17255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17256 
 
17257 
  def __eq__(self, other):
17258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17259 
 
17260 
  def __ne__(self, other):
17261 
    return not (self == other)
17262 
 
17263 
class getBillingAddressForUser_result:
17264 
  """
17265 
  Attributes:
17266 
   - success
17267 
  """
17268 
 
17269 
  thrift_spec = (
17270 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17271 
  )
17272 
 
17273 
  def __init__(self, success=None,):
17274 
    self.success = success
17275 
 
17276 
  def read(self, iprot):
17277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17279 
      return
17280 
    iprot.readStructBegin()
17281 
    while True:
17282 
      (fname, ftype, fid) = iprot.readFieldBegin()
17283 
      if ftype == TType.STOP:
17284 
        break
17285 
      if fid == 0:
17286 
        if ftype == TType.STRUCT:
17287 
          self.success = Address()
17288 
          self.success.read(iprot)
17289 
        else:
17290 
          iprot.skip(ftype)
17291 
      else:
17292 
        iprot.skip(ftype)
17293 
      iprot.readFieldEnd()
17294 
    iprot.readStructEnd()
17295 
 
17296 
  def write(self, oprot):
17297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17299 
      return
17300 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17301 
    if self.success is not None:
17302 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17303 
      self.success.write(oprot)
17304 
      oprot.writeFieldEnd()
17305 
    oprot.writeFieldStop()
17306 
    oprot.writeStructEnd()
17307 
 
17308 
  def validate(self):
17309 
    return
17310 
 
17311 
 
17312 
  def __repr__(self):
17313 
    L = ['%s=%r' % (key, value)
17314 
      for key, value in self.__dict__.iteritems()]
17315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17316 
 
17317 
  def __eq__(self, other):
17318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17319 
 
17320 
  def __ne__(self, other):
17321 
    return not (self == other)
18590 manish.sha 17322 
 
17323 
class isCreditorAssigned_args:
17324 
  """
17325 
  Attributes:
17326 
   - userId
17327 
  """
17328 
 
17329 
  thrift_spec = (
17330 
    None, # 0
17331 
    (1, TType.I64, 'userId', None, None, ), # 1
17332 
  )
17333 
 
17334 
  def __init__(self, userId=None,):
17335 
    self.userId = userId
17336 
 
17337 
  def read(self, iprot):
17338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17340 
      return
17341 
    iprot.readStructBegin()
17342 
    while True:
17343 
      (fname, ftype, fid) = iprot.readFieldBegin()
17344 
      if ftype == TType.STOP:
17345 
        break
17346 
      if fid == 1:
17347 
        if ftype == TType.I64:
17348 
          self.userId = iprot.readI64();
17349 
        else:
17350 
          iprot.skip(ftype)
17351 
      else:
17352 
        iprot.skip(ftype)
17353 
      iprot.readFieldEnd()
17354 
    iprot.readStructEnd()
17355 
 
17356 
  def write(self, oprot):
17357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17359 
      return
17360 
    oprot.writeStructBegin('isCreditorAssigned_args')
17361 
    if self.userId is not None:
17362 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17363 
      oprot.writeI64(self.userId)
17364 
      oprot.writeFieldEnd()
17365 
    oprot.writeFieldStop()
17366 
    oprot.writeStructEnd()
17367 
 
17368 
  def validate(self):
17369 
    return
17370 
 
17371 
 
17372 
  def __repr__(self):
17373 
    L = ['%s=%r' % (key, value)
17374 
      for key, value in self.__dict__.iteritems()]
17375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17376 
 
17377 
  def __eq__(self, other):
17378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17379 
 
17380 
  def __ne__(self, other):
17381 
    return not (self == other)
17382 
 
17383 
class isCreditorAssigned_result:
17384 
  """
17385 
  Attributes:
17386 
   - success
17387 
  """
17388 
 
17389 
  thrift_spec = (
17390 
    (0, TType.BOOL, 'success', None, None, ), # 0
17391 
  )
17392 
 
17393 
  def __init__(self, success=None,):
17394 
    self.success = success
17395 
 
17396 
  def read(self, iprot):
17397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17399 
      return
17400 
    iprot.readStructBegin()
17401 
    while True:
17402 
      (fname, ftype, fid) = iprot.readFieldBegin()
17403 
      if ftype == TType.STOP:
17404 
        break
17405 
      if fid == 0:
17406 
        if ftype == TType.BOOL:
17407 
          self.success = iprot.readBool();
17408 
        else:
17409 
          iprot.skip(ftype)
17410 
      else:
17411 
        iprot.skip(ftype)
17412 
      iprot.readFieldEnd()
17413 
    iprot.readStructEnd()
17414 
 
17415 
  def write(self, oprot):
17416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17418 
      return
17419 
    oprot.writeStructBegin('isCreditorAssigned_result')
17420 
    if self.success is not None:
17421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17422 
      oprot.writeBool(self.success)
17423 
      oprot.writeFieldEnd()
17424 
    oprot.writeFieldStop()
17425 
    oprot.writeStructEnd()
17426 
 
17427 
  def validate(self):
17428 
    return
17429 
 
17430 
 
17431 
  def __repr__(self):
17432 
    L = ['%s=%r' % (key, value)
17433 
      for key, value in self.__dict__.iteritems()]
17434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17435 
 
17436 
  def __eq__(self, other):
17437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17438 
 
17439 
  def __ne__(self, other):
17440 
    return not (self == other)
18735 manish.sha 17441 
 
17442 
class isTaxInvoiceEnabledUser_args:
17443 
  """
17444 
  Attributes:
17445 
   - userId
17446 
  """
17447 
 
17448 
  thrift_spec = (
17449 
    None, # 0
17450 
    (1, TType.I64, 'userId', None, None, ), # 1
17451 
  )
17452 
 
17453 
  def __init__(self, userId=None,):
17454 
    self.userId = userId
17455 
 
17456 
  def read(self, iprot):
17457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17459 
      return
17460 
    iprot.readStructBegin()
17461 
    while True:
17462 
      (fname, ftype, fid) = iprot.readFieldBegin()
17463 
      if ftype == TType.STOP:
17464 
        break
17465 
      if fid == 1:
17466 
        if ftype == TType.I64:
17467 
          self.userId = iprot.readI64();
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      else:
17471 
        iprot.skip(ftype)
17472 
      iprot.readFieldEnd()
17473 
    iprot.readStructEnd()
17474 
 
17475 
  def write(self, oprot):
17476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17478 
      return
17479 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17480 
    if self.userId is not None:
17481 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17482 
      oprot.writeI64(self.userId)
17483 
      oprot.writeFieldEnd()
17484 
    oprot.writeFieldStop()
17485 
    oprot.writeStructEnd()
17486 
 
17487 
  def validate(self):
17488 
    return
17489 
 
17490 
 
17491 
  def __repr__(self):
17492 
    L = ['%s=%r' % (key, value)
17493 
      for key, value in self.__dict__.iteritems()]
17494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17495 
 
17496 
  def __eq__(self, other):
17497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17498 
 
17499 
  def __ne__(self, other):
17500 
    return not (self == other)
17501 
 
17502 
class isTaxInvoiceEnabledUser_result:
17503 
  """
17504 
  Attributes:
17505 
   - success
17506 
  """
17507 
 
17508 
  thrift_spec = (
17509 
    (0, TType.BOOL, 'success', None, None, ), # 0
17510 
  )
17511 
 
17512 
  def __init__(self, success=None,):
17513 
    self.success = success
17514 
 
17515 
  def read(self, iprot):
17516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17518 
      return
17519 
    iprot.readStructBegin()
17520 
    while True:
17521 
      (fname, ftype, fid) = iprot.readFieldBegin()
17522 
      if ftype == TType.STOP:
17523 
        break
17524 
      if fid == 0:
17525 
        if ftype == TType.BOOL:
17526 
          self.success = iprot.readBool();
17527 
        else:
17528 
          iprot.skip(ftype)
17529 
      else:
17530 
        iprot.skip(ftype)
17531 
      iprot.readFieldEnd()
17532 
    iprot.readStructEnd()
17533 
 
17534 
  def write(self, oprot):
17535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17537 
      return
17538 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17539 
    if self.success is not None:
17540 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17541 
      oprot.writeBool(self.success)
17542 
      oprot.writeFieldEnd()
17543 
    oprot.writeFieldStop()
17544 
    oprot.writeStructEnd()
17545 
 
17546 
  def validate(self):
17547 
    return
17548 
 
17549 
 
17550 
  def __repr__(self):
17551 
    L = ['%s=%r' % (key, value)
17552 
      for key, value in self.__dict__.iteritems()]
17553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17554 
 
17555 
  def __eq__(self, other):
17556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17557 
 
17558 
  def __ne__(self, other):
17559 
    return not (self == other)
18764 kshitij.so 17560 
 
19182 amit.gupta 17561 
class taxInvoiceAvailable_args:
17562 
  """
17563 
  Attributes:
17564 
   - addressId
17565 
  """
17566 
 
17567 
  thrift_spec = (
17568 
    None, # 0
17569 
    (1, TType.I64, 'addressId', None, None, ), # 1
17570 
  )
17571 
 
17572 
  def __init__(self, addressId=None,):
17573 
    self.addressId = addressId
17574 
 
17575 
  def read(self, iprot):
17576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17578 
      return
17579 
    iprot.readStructBegin()
17580 
    while True:
17581 
      (fname, ftype, fid) = iprot.readFieldBegin()
17582 
      if ftype == TType.STOP:
17583 
        break
17584 
      if fid == 1:
17585 
        if ftype == TType.I64:
17586 
          self.addressId = iprot.readI64();
17587 
        else:
17588 
          iprot.skip(ftype)
17589 
      else:
17590 
        iprot.skip(ftype)
17591 
      iprot.readFieldEnd()
17592 
    iprot.readStructEnd()
17593 
 
17594 
  def write(self, oprot):
17595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17597 
      return
17598 
    oprot.writeStructBegin('taxInvoiceAvailable_args')
17599 
    if self.addressId is not None:
17600 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
17601 
      oprot.writeI64(self.addressId)
17602 
      oprot.writeFieldEnd()
17603 
    oprot.writeFieldStop()
17604 
    oprot.writeStructEnd()
17605 
 
17606 
  def validate(self):
17607 
    return
17608 
 
17609 
 
17610 
  def __repr__(self):
17611 
    L = ['%s=%r' % (key, value)
17612 
      for key, value in self.__dict__.iteritems()]
17613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17614 
 
17615 
  def __eq__(self, other):
17616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17617 
 
17618 
  def __ne__(self, other):
17619 
    return not (self == other)
17620 
 
17621 
class taxInvoiceAvailable_result:
17622 
  """
17623 
  Attributes:
17624 
   - success
17625 
  """
17626 
 
17627 
  thrift_spec = (
17628 
    (0, TType.BOOL, 'success', None, None, ), # 0
17629 
  )
17630 
 
17631 
  def __init__(self, success=None,):
17632 
    self.success = success
17633 
 
17634 
  def read(self, iprot):
17635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17637 
      return
17638 
    iprot.readStructBegin()
17639 
    while True:
17640 
      (fname, ftype, fid) = iprot.readFieldBegin()
17641 
      if ftype == TType.STOP:
17642 
        break
17643 
      if fid == 0:
17644 
        if ftype == TType.BOOL:
17645 
          self.success = iprot.readBool();
17646 
        else:
17647 
          iprot.skip(ftype)
17648 
      else:
17649 
        iprot.skip(ftype)
17650 
      iprot.readFieldEnd()
17651 
    iprot.readStructEnd()
17652 
 
17653 
  def write(self, oprot):
17654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17656 
      return
17657 
    oprot.writeStructBegin('taxInvoiceAvailable_result')
17658 
    if self.success is not None:
17659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17660 
      oprot.writeBool(self.success)
17661 
      oprot.writeFieldEnd()
17662 
    oprot.writeFieldStop()
17663 
    oprot.writeStructEnd()
17664 
 
17665 
  def validate(self):
17666 
    return
17667 
 
17668 
 
17669 
  def __repr__(self):
17670 
    L = ['%s=%r' % (key, value)
17671 
      for key, value in self.__dict__.iteritems()]
17672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17673 
 
17674 
  def __eq__(self, other):
17675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17676 
 
17677 
  def __ne__(self, other):
17678 
    return not (self == other)
17679 
 
18764 kshitij.so 17680 
class getCartByValue_args:
17681 
  """
17682 
  Attributes:
17683 
   - cartIds
17684 
  """
17685 
 
17686 
  thrift_spec = (
17687 
    None, # 0
17688 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17689 
  )
17690 
 
17691 
  def __init__(self, cartIds=None,):
17692 
    self.cartIds = cartIds
17693 
 
17694 
  def read(self, iprot):
17695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17697 
      return
17698 
    iprot.readStructBegin()
17699 
    while True:
17700 
      (fname, ftype, fid) = iprot.readFieldBegin()
17701 
      if ftype == TType.STOP:
17702 
        break
17703 
      if fid == 1:
17704 
        if ftype == TType.LIST:
17705 
          self.cartIds = []
17706 
          (_etype258, _size255) = iprot.readListBegin()
17707 
          for _i259 in xrange(_size255):
17708 
            _elem260 = iprot.readI64();
17709 
            self.cartIds.append(_elem260)
17710 
          iprot.readListEnd()
17711 
        else:
17712 
          iprot.skip(ftype)
17713 
      else:
17714 
        iprot.skip(ftype)
17715 
      iprot.readFieldEnd()
17716 
    iprot.readStructEnd()
17717 
 
17718 
  def write(self, oprot):
17719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17721 
      return
17722 
    oprot.writeStructBegin('getCartByValue_args')
17723 
    if self.cartIds is not None:
17724 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17725 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17726 
      for iter261 in self.cartIds:
17727 
        oprot.writeI64(iter261)
17728 
      oprot.writeListEnd()
17729 
      oprot.writeFieldEnd()
17730 
    oprot.writeFieldStop()
17731 
    oprot.writeStructEnd()
17732 
 
17733 
  def validate(self):
17734 
    return
17735 
 
17736 
 
17737 
  def __repr__(self):
17738 
    L = ['%s=%r' % (key, value)
17739 
      for key, value in self.__dict__.iteritems()]
17740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17741 
 
17742 
  def __eq__(self, other):
17743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17744 
 
17745 
  def __ne__(self, other):
17746 
    return not (self == other)
17747 
 
17748 
class getCartByValue_result:
17749 
  """
17750 
  Attributes:
17751 
   - success
17752 
  """
17753 
 
17754 
  thrift_spec = (
17755 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17756 
  )
17757 
 
17758 
  def __init__(self, success=None,):
17759 
    self.success = success
17760 
 
17761 
  def read(self, iprot):
17762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17764 
      return
17765 
    iprot.readStructBegin()
17766 
    while True:
17767 
      (fname, ftype, fid) = iprot.readFieldBegin()
17768 
      if ftype == TType.STOP:
17769 
        break
17770 
      if fid == 0:
17771 
        if ftype == TType.MAP:
17772 
          self.success = {}
17773 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17774 
          for _i266 in xrange(_size262):
17775 
            _key267 = iprot.readI64();
17776 
            _val268 = []
17777 
            (_etype272, _size269) = iprot.readListBegin()
17778 
            for _i273 in xrange(_size269):
17779 
              _elem274 = Line()
17780 
              _elem274.read(iprot)
17781 
              _val268.append(_elem274)
17782 
            iprot.readListEnd()
17783 
            self.success[_key267] = _val268
17784 
          iprot.readMapEnd()
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      else:
17788 
        iprot.skip(ftype)
17789 
      iprot.readFieldEnd()
17790 
    iprot.readStructEnd()
17791 
 
17792 
  def write(self, oprot):
17793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17795 
      return
17796 
    oprot.writeStructBegin('getCartByValue_result')
17797 
    if self.success is not None:
17798 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17799 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17800 
      for kiter275,viter276 in self.success.items():
17801 
        oprot.writeI64(kiter275)
17802 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17803 
        for iter277 in viter276:
17804 
          iter277.write(oprot)
17805 
        oprot.writeListEnd()
17806 
      oprot.writeMapEnd()
17807 
      oprot.writeFieldEnd()
17808 
    oprot.writeFieldStop()
17809 
    oprot.writeStructEnd()
17810 
 
17811 
  def validate(self):
17812 
    return
17813 
 
17814 
 
17815 
  def __repr__(self):
17816 
    L = ['%s=%r' % (key, value)
17817 
      for key, value in self.__dict__.iteritems()]
17818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17819 
 
17820 
  def __eq__(self, other):
17821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17822 
 
17823 
  def __ne__(self, other):
17824 
    return not (self == other)