Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
12722 amit.gupta 713 
  def getAllUsersByCounter(self, counterId):
714 
    """
715 
    Parameters:
716 
     - counterId
717 
    """
718 
    pass
719 
 
15251 manish.sha 720 
  def getActiveAccessTokenForUser(self, userId, source):
721 
    """
722 
    Parameters:
723 
     - userId
724 
     - source
725 
    """
726 
    pass
12722 amit.gupta 727 
 
15251 manish.sha 728 
  def validateAccessToken(self, accessToken):
729 
    """
730 
    Parameters:
731 
     - accessToken
732 
    """
733 
    pass
734 
 
17782 amit.gupta 735 
  def addItemsToCart(self, cartId, itemQty, couponCode):
736 
    """
737 
    Parameters:
738 
     - cartId
739 
     - itemQty
740 
     - couponCode
741 
    """
742 
    pass
15251 manish.sha 743 
 
17782 amit.gupta 744 
  def validateCartNew(self, cartId, pinCode, sourceId):
745 
    """
746 
    Parameters:
747 
     - cartId
748 
     - pinCode
749 
     - sourceId
750 
    """
751 
    pass
752 
 
753 
 
3376 rajveer 754 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 755 
  """
756 
  service
757 
  """
758 
  def __init__(self, iprot, oprot=None):
3376 rajveer 759 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 760 
 
559 chandransh 761 
  def createAnonymousUser(self, jsessionId):
94 ashish 762 
    """
763 
    Parameters:
559 chandransh 764 
     - jsessionId
94 ashish 765 
    """
559 chandransh 766 
    self.send_createAnonymousUser(jsessionId)
767 
    return self.recv_createAnonymousUser()
94 ashish 768 
 
559 chandransh 769 
  def send_createAnonymousUser(self, jsessionId):
770 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
771 
    args = createAnonymousUser_args()
772 
    args.jsessionId = jsessionId
94 ashish 773 
    args.write(self._oprot)
774 
    self._oprot.writeMessageEnd()
775 
    self._oprot.trans.flush()
776 
 
559 chandransh 777 
  def recv_createAnonymousUser(self, ):
94 ashish 778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
779 
    if mtype == TMessageType.EXCEPTION:
780 
      x = TApplicationException()
781 
      x.read(self._iprot)
782 
      self._iprot.readMessageEnd()
783 
      raise x
559 chandransh 784 
    result = createAnonymousUser_result()
94 ashish 785 
    result.read(self._iprot)
786 
    self._iprot.readMessageEnd()
3431 rajveer 787 
    if result.success is not None:
94 ashish 788 
      return result.success
3431 rajveer 789 
    if result.ucex is not None:
559 chandransh 790 
      raise result.ucex
791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 792 
 
559 chandransh 793 
  def getUserById(self, userId):
94 ashish 794 
    """
795 
    Parameters:
796 
     - userId
797 
    """
559 chandransh 798 
    self.send_getUserById(userId)
799 
    return self.recv_getUserById()
94 ashish 800 
 
559 chandransh 801 
  def send_getUserById(self, userId):
802 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
803 
    args = getUserById_args()
94 ashish 804 
    args.userId = userId
805 
    args.write(self._oprot)
806 
    self._oprot.writeMessageEnd()
807 
    self._oprot.trans.flush()
808 
 
559 chandransh 809 
  def recv_getUserById(self, ):
94 ashish 810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
811 
    if mtype == TMessageType.EXCEPTION:
812 
      x = TApplicationException()
813 
      x.read(self._iprot)
814 
      self._iprot.readMessageEnd()
815 
      raise x
559 chandransh 816 
    result = getUserById_result()
94 ashish 817 
    result.read(self._iprot)
818 
    self._iprot.readMessageEnd()
3431 rajveer 819 
    if result.success is not None:
94 ashish 820 
      return result.success
3431 rajveer 821 
    if result.ucex is not None:
559 chandransh 822 
      raise result.ucex
823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 824 
 
5326 rajveer 825 
  def getUserByCartId(self, cartId):
826 
    """
827 
    Parameters:
828 
     - cartId
829 
    """
830 
    self.send_getUserByCartId(cartId)
831 
    return self.recv_getUserByCartId()
832 
 
833 
  def send_getUserByCartId(self, cartId):
834 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
835 
    args = getUserByCartId_args()
836 
    args.cartId = cartId
837 
    args.write(self._oprot)
838 
    self._oprot.writeMessageEnd()
839 
    self._oprot.trans.flush()
840 
 
841 
  def recv_getUserByCartId(self, ):
842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
843 
    if mtype == TMessageType.EXCEPTION:
844 
      x = TApplicationException()
845 
      x.read(self._iprot)
846 
      self._iprot.readMessageEnd()
847 
      raise x
848 
    result = getUserByCartId_result()
849 
    result.read(self._iprot)
850 
    self._iprot.readMessageEnd()
851 
    if result.success is not None:
852 
      return result.success
853 
    if result.ucex is not None:
854 
      raise result.ucex
855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
856 
 
1491 vikas 857 
  def getUserByEmail(self, email):
858 
    """
859 
    Parameters:
860 
     - email
861 
    """
862 
    self.send_getUserByEmail(email)
863 
    return self.recv_getUserByEmail()
864 
 
865 
  def send_getUserByEmail(self, email):
866 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
867 
    args = getUserByEmail_args()
868 
    args.email = email
869 
    args.write(self._oprot)
870 
    self._oprot.writeMessageEnd()
871 
    self._oprot.trans.flush()
872 
 
873 
  def recv_getUserByEmail(self, ):
874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
875 
    if mtype == TMessageType.EXCEPTION:
876 
      x = TApplicationException()
877 
      x.read(self._iprot)
878 
      self._iprot.readMessageEnd()
879 
      raise x
880 
    result = getUserByEmail_result()
881 
    result.read(self._iprot)
882 
    self._iprot.readMessageEnd()
3431 rajveer 883 
    if result.success is not None:
1491 vikas 884 
      return result.success
3431 rajveer 885 
    if result.ucex is not None:
1491 vikas 886 
      raise result.ucex
887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
888 
 
3032 mandeep.dh 889 
  def getUserByMobileNumber(self, mobileNumber):
890 
    """
891 
    Parameters:
892 
     - mobileNumber
893 
    """
894 
    self.send_getUserByMobileNumber(mobileNumber)
895 
    return self.recv_getUserByMobileNumber()
896 
 
897 
  def send_getUserByMobileNumber(self, mobileNumber):
898 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
899 
    args = getUserByMobileNumber_args()
900 
    args.mobileNumber = mobileNumber
901 
    args.write(self._oprot)
902 
    self._oprot.writeMessageEnd()
903 
    self._oprot.trans.flush()
904 
 
905 
  def recv_getUserByMobileNumber(self, ):
906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
907 
    if mtype == TMessageType.EXCEPTION:
908 
      x = TApplicationException()
909 
      x.read(self._iprot)
910 
      self._iprot.readMessageEnd()
911 
      raise x
912 
    result = getUserByMobileNumber_result()
913 
    result.read(self._iprot)
914 
    self._iprot.readMessageEnd()
3431 rajveer 915 
    if result.success is not None:
3032 mandeep.dh 916 
      return result.success
3431 rajveer 917 
    if result.ucex is not None:
3032 mandeep.dh 918 
      raise result.ucex
919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
920 
 
559 chandransh 921 
  def createUser(self, user):
94 ashish 922 
    """
923 
    Parameters:
559 chandransh 924 
     - user
94 ashish 925 
    """
559 chandransh 926 
    self.send_createUser(user)
927 
    return self.recv_createUser()
94 ashish 928 
 
559 chandransh 929 
  def send_createUser(self, user):
930 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
931 
    args = createUser_args()
932 
    args.user = user
94 ashish 933 
    args.write(self._oprot)
934 
    self._oprot.writeMessageEnd()
935 
    self._oprot.trans.flush()
936 
 
559 chandransh 937 
  def recv_createUser(self, ):
94 ashish 938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
939 
    if mtype == TMessageType.EXCEPTION:
940 
      x = TApplicationException()
941 
      x.read(self._iprot)
942 
      self._iprot.readMessageEnd()
943 
      raise x
559 chandransh 944 
    result = createUser_result()
94 ashish 945 
    result.read(self._iprot)
946 
    self._iprot.readMessageEnd()
3431 rajveer 947 
    if result.success is not None:
94 ashish 948 
      return result.success
3431 rajveer 949 
    if result.ucex is not None:
559 chandransh 950 
      raise result.ucex
951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 952 
 
559 chandransh 953 
  def updateUser(self, user):
94 ashish 954 
    """
955 
    Parameters:
559 chandransh 956 
     - user
94 ashish 957 
    """
559 chandransh 958 
    self.send_updateUser(user)
959 
    return self.recv_updateUser()
94 ashish 960 
 
559 chandransh 961 
  def send_updateUser(self, user):
962 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
963 
    args = updateUser_args()
964 
    args.user = user
94 ashish 965 
    args.write(self._oprot)
966 
    self._oprot.writeMessageEnd()
967 
    self._oprot.trans.flush()
968 
 
559 chandransh 969 
  def recv_updateUser(self, ):
94 ashish 970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
971 
    if mtype == TMessageType.EXCEPTION:
972 
      x = TApplicationException()
973 
      x.read(self._iprot)
974 
      self._iprot.readMessageEnd()
975 
      raise x
559 chandransh 976 
    result = updateUser_result()
94 ashish 977 
    result.read(self._iprot)
978 
    self._iprot.readMessageEnd()
3431 rajveer 979 
    if result.success is not None:
94 ashish 980 
      return result.success
3431 rajveer 981 
    if result.ucex is not None:
559 chandransh 982 
      raise result.ucex
983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 984 
 
559 chandransh 985 
  def authenticateUser(self, email, password):
94 ashish 986 
    """
987 
    Parameters:
988 
     - email
989 
     - password
990 
    """
559 chandransh 991 
    self.send_authenticateUser(email, password)
122 ashish 992 
    return self.recv_authenticateUser()
993 
 
559 chandransh 994 
  def send_authenticateUser(self, email, password):
122 ashish 995 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
996 
    args = authenticateUser_args()
559 chandransh 997 
    args.email = email
122 ashish 998 
    args.password = password
999 
    args.write(self._oprot)
1000 
    self._oprot.writeMessageEnd()
1001 
    self._oprot.trans.flush()
1002 
 
1003 
  def recv_authenticateUser(self, ):
1004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1005 
    if mtype == TMessageType.EXCEPTION:
1006 
      x = TApplicationException()
1007 
      x.read(self._iprot)
1008 
      self._iprot.readMessageEnd()
1009 
      raise x
1010 
    result = authenticateUser_result()
1011 
    result.read(self._iprot)
1012 
    self._iprot.readMessageEnd()
3431 rajveer 1013 
    if result.success is not None:
122 ashish 1014 
      return result.success
3431 rajveer 1015 
    if result.auex is not None:
559 chandransh 1016 
      raise result.auex
122 ashish 1017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1018 
 
94 ashish 1019 
  def userExists(self, email):
1020 
    """
1021 
    Parameters:
1022 
     - email
1023 
    """
1024 
    self.send_userExists(email)
1025 
    return self.recv_userExists()
1026 
 
1027 
  def send_userExists(self, email):
1028 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1029 
    args = userExists_args()
1030 
    args.email = email
1031 
    args.write(self._oprot)
1032 
    self._oprot.writeMessageEnd()
1033 
    self._oprot.trans.flush()
1034 
 
1035 
  def recv_userExists(self, ):
1036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1037 
    if mtype == TMessageType.EXCEPTION:
1038 
      x = TApplicationException()
1039 
      x.read(self._iprot)
1040 
      self._iprot.readMessageEnd()
1041 
      raise x
1042 
    result = userExists_result()
1043 
    result.read(self._iprot)
1044 
    self._iprot.readMessageEnd()
3431 rajveer 1045 
    if result.success is not None:
94 ashish 1046 
      return result.success
3431 rajveer 1047 
    if result.ucx is not None:
94 ashish 1048 
      raise result.ucx
1049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1050 
 
567 rajveer 1051 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1052 
    """
1053 
    Parameters:
1054 
     - userId
1055 
     - address
513 rajveer 1056 
     - setDefault
94 ashish 1057 
    """
567 rajveer 1058 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1059 
    return self.recv_addAddressForUser()
1060 
 
567 rajveer 1061 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1062 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1063 
    args = addAddressForUser_args()
559 chandransh 1064 
    args.userId = userId
94 ashish 1065 
    args.address = address
513 rajveer 1066 
    args.setDefault = setDefault
94 ashish 1067 
    args.write(self._oprot)
1068 
    self._oprot.writeMessageEnd()
1069 
    self._oprot.trans.flush()
1070 
 
1071 
  def recv_addAddressForUser(self, ):
1072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1073 
    if mtype == TMessageType.EXCEPTION:
1074 
      x = TApplicationException()
1075 
      x.read(self._iprot)
1076 
      self._iprot.readMessageEnd()
1077 
      raise x
1078 
    result = addAddressForUser_result()
1079 
    result.read(self._iprot)
1080 
    self._iprot.readMessageEnd()
3431 rajveer 1081 
    if result.success is not None:
94 ashish 1082 
      return result.success
3431 rajveer 1083 
    if result.ucx is not None:
94 ashish 1084 
      raise result.ucx
1085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1086 
 
1087 
  def removeAddressForUser(self, userid, addressId):
1088 
    """
1089 
    Parameters:
1090 
     - userid
1091 
     - addressId
1092 
    """
1093 
    self.send_removeAddressForUser(userid, addressId)
1094 
    return self.recv_removeAddressForUser()
1095 
 
1096 
  def send_removeAddressForUser(self, userid, addressId):
1097 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1098 
    args = removeAddressForUser_args()
1099 
    args.userid = userid
1100 
    args.addressId = addressId
1101 
    args.write(self._oprot)
1102 
    self._oprot.writeMessageEnd()
1103 
    self._oprot.trans.flush()
1104 
 
1105 
  def recv_removeAddressForUser(self, ):
1106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1107 
    if mtype == TMessageType.EXCEPTION:
1108 
      x = TApplicationException()
1109 
      x.read(self._iprot)
1110 
      self._iprot.readMessageEnd()
1111 
      raise x
1112 
    result = removeAddressForUser_result()
1113 
    result.read(self._iprot)
1114 
    self._iprot.readMessageEnd()
3431 rajveer 1115 
    if result.success is not None:
94 ashish 1116 
      return result.success
3431 rajveer 1117 
    if result.ucx is not None:
94 ashish 1118 
      raise result.ucx
1119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1120 
 
1121 
  def setUserAsLoggedIn(self, userId, timestamp):
1122 
    """
1123 
    Parameters:
1124 
     - userId
1125 
     - timestamp
1126 
    """
1127 
    self.send_setUserAsLoggedIn(userId, timestamp)
1128 
    return self.recv_setUserAsLoggedIn()
1129 
 
1130 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1131 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1132 
    args = setUserAsLoggedIn_args()
1133 
    args.userId = userId
1134 
    args.timestamp = timestamp
1135 
    args.write(self._oprot)
1136 
    self._oprot.writeMessageEnd()
1137 
    self._oprot.trans.flush()
1138 
 
1139 
  def recv_setUserAsLoggedIn(self, ):
1140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1141 
    if mtype == TMessageType.EXCEPTION:
1142 
      x = TApplicationException()
1143 
      x.read(self._iprot)
1144 
      self._iprot.readMessageEnd()
1145 
      raise x
1146 
    result = setUserAsLoggedIn_result()
1147 
    result.read(self._iprot)
1148 
    self._iprot.readMessageEnd()
3431 rajveer 1149 
    if result.success is not None:
94 ashish 1150 
      return result.success
3431 rajveer 1151 
    if result.ucx is not None:
94 ashish 1152 
      raise result.ucx
1153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1154 
 
1155 
  def setUserAsLoggedOut(self, userid, timestamp):
1156 
    """
1157 
    Parameters:
1158 
     - userid
1159 
     - timestamp
1160 
    """
1161 
    self.send_setUserAsLoggedOut(userid, timestamp)
1162 
    return self.recv_setUserAsLoggedOut()
1163 
 
1164 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1165 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1166 
    args = setUserAsLoggedOut_args()
1167 
    args.userid = userid
1168 
    args.timestamp = timestamp
1169 
    args.write(self._oprot)
1170 
    self._oprot.writeMessageEnd()
1171 
    self._oprot.trans.flush()
1172 
 
1173 
  def recv_setUserAsLoggedOut(self, ):
1174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1175 
    if mtype == TMessageType.EXCEPTION:
1176 
      x = TApplicationException()
1177 
      x.read(self._iprot)
1178 
      self._iprot.readMessageEnd()
1179 
      raise x
1180 
    result = setUserAsLoggedOut_result()
1181 
    result.read(self._iprot)
1182 
    self._iprot.readMessageEnd()
3431 rajveer 1183 
    if result.success is not None:
94 ashish 1184 
      return result.success
3431 rajveer 1185 
    if result.ucx is not None:
94 ashish 1186 
      raise result.ucx
1187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1188 
 
504 rajveer 1189 
  def setDefaultAddress(self, userid, addressId):
1190 
    """
1191 
    Parameters:
1192 
     - userid
1193 
     - addressId
1194 
    """
1195 
    self.send_setDefaultAddress(userid, addressId)
1196 
    return self.recv_setDefaultAddress()
1197 
 
1198 
  def send_setDefaultAddress(self, userid, addressId):
1199 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1200 
    args = setDefaultAddress_args()
1201 
    args.userid = userid
1202 
    args.addressId = addressId
1203 
    args.write(self._oprot)
1204 
    self._oprot.writeMessageEnd()
1205 
    self._oprot.trans.flush()
1206 
 
1207 
  def recv_setDefaultAddress(self, ):
1208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1209 
    if mtype == TMessageType.EXCEPTION:
1210 
      x = TApplicationException()
1211 
      x.read(self._iprot)
1212 
      self._iprot.readMessageEnd()
1213 
      raise x
1214 
    result = setDefaultAddress_result()
1215 
    result.read(self._iprot)
1216 
    self._iprot.readMessageEnd()
3431 rajveer 1217 
    if result.success is not None:
504 rajveer 1218 
      return result.success
3431 rajveer 1219 
    if result.ucx is not None:
504 rajveer 1220 
      raise result.ucx
1221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1222 
 
594 rajveer 1223 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1224 
    """
1225 
    Parameters:
1226 
     - userid
594 rajveer 1227 
     - oldPassword
1228 
     - newPassword
94 ashish 1229 
    """
594 rajveer 1230 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1231 
    return self.recv_updatePassword()
1232 
 
594 rajveer 1233 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1234 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1235 
    args = updatePassword_args()
1236 
    args.userid = userid
594 rajveer 1237 
    args.oldPassword = oldPassword
1238 
    args.newPassword = newPassword
94 ashish 1239 
    args.write(self._oprot)
1240 
    self._oprot.writeMessageEnd()
1241 
    self._oprot.trans.flush()
1242 
 
1243 
  def recv_updatePassword(self, ):
1244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1245 
    if mtype == TMessageType.EXCEPTION:
1246 
      x = TApplicationException()
1247 
      x.read(self._iprot)
1248 
      self._iprot.readMessageEnd()
1249 
      raise x
1250 
    result = updatePassword_result()
1251 
    result.read(self._iprot)
1252 
    self._iprot.readMessageEnd()
3431 rajveer 1253 
    if result.success is not None:
94 ashish 1254 
      return result.success
3431 rajveer 1255 
    if result.ucx is not None:
94 ashish 1256 
      raise result.ucx
1257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1258 
 
884 rajveer 1259 
  def forgotPassword(self, email, newPassword):
581 rajveer 1260 
    """
1261 
    Parameters:
1262 
     - email
884 rajveer 1263 
     - newPassword
581 rajveer 1264 
    """
884 rajveer 1265 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1266 
    return self.recv_forgotPassword()
1267 
 
884 rajveer 1268 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1269 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1270 
    args = forgotPassword_args()
1271 
    args.email = email
884 rajveer 1272 
    args.newPassword = newPassword
581 rajveer 1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
1277 
  def recv_forgotPassword(self, ):
1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
1284 
    result = forgotPassword_result()
1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
3431 rajveer 1287 
    if result.success is not None:
581 rajveer 1288 
      return result.success
3431 rajveer 1289 
    if result.ucx is not None:
581 rajveer 1290 
      raise result.ucx
1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1292 
 
594 rajveer 1293 
  def getAllAddressesForUser(self, userId):
1294 
    """
1295 
    Parameters:
1296 
     - userId
1297 
    """
1298 
    self.send_getAllAddressesForUser(userId)
1299 
    return self.recv_getAllAddressesForUser()
1300 
 
1301 
  def send_getAllAddressesForUser(self, userId):
1302 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1303 
    args = getAllAddressesForUser_args()
1304 
    args.userId = userId
1305 
    args.write(self._oprot)
1306 
    self._oprot.writeMessageEnd()
1307 
    self._oprot.trans.flush()
1308 
 
1309 
  def recv_getAllAddressesForUser(self, ):
1310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1311 
    if mtype == TMessageType.EXCEPTION:
1312 
      x = TApplicationException()
1313 
      x.read(self._iprot)
1314 
      self._iprot.readMessageEnd()
1315 
      raise x
1316 
    result = getAllAddressesForUser_result()
1317 
    result.read(self._iprot)
1318 
    self._iprot.readMessageEnd()
3431 rajveer 1319 
    if result.success is not None:
594 rajveer 1320 
      return result.success
3431 rajveer 1321 
    if result.ucx is not None:
594 rajveer 1322 
      raise result.ucx
1323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1324 
 
1894 vikas 1325 
  def getAddressById(self, addressId):
1326 
    """
1327 
    Parameters:
1328 
     - addressId
1329 
    """
1330 
    self.send_getAddressById(addressId)
1331 
    return self.recv_getAddressById()
1332 
 
1333 
  def send_getAddressById(self, addressId):
1334 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1335 
    args = getAddressById_args()
1336 
    args.addressId = addressId
1337 
    args.write(self._oprot)
1338 
    self._oprot.writeMessageEnd()
1339 
    self._oprot.trans.flush()
1340 
 
1341 
  def recv_getAddressById(self, ):
1342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1343 
    if mtype == TMessageType.EXCEPTION:
1344 
      x = TApplicationException()
1345 
      x.read(self._iprot)
1346 
      self._iprot.readMessageEnd()
1347 
      raise x
1348 
    result = getAddressById_result()
1349 
    result.read(self._iprot)
1350 
    self._iprot.readMessageEnd()
3431 rajveer 1351 
    if result.success is not None:
1894 vikas 1352 
      return result.success
3431 rajveer 1353 
    if result.ucx is not None:
1894 vikas 1354 
      raise result.ucx
1355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1356 
 
594 rajveer 1357 
  def getDefaultAddressId(self, userId):
1358 
    """
1359 
    Parameters:
1360 
     - userId
1361 
    """
1362 
    self.send_getDefaultAddressId(userId)
1363 
    return self.recv_getDefaultAddressId()
1364 
 
1365 
  def send_getDefaultAddressId(self, userId):
1366 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1367 
    args = getDefaultAddressId_args()
1368 
    args.userId = userId
1369 
    args.write(self._oprot)
1370 
    self._oprot.writeMessageEnd()
1371 
    self._oprot.trans.flush()
1372 
 
1373 
  def recv_getDefaultAddressId(self, ):
1374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1375 
    if mtype == TMessageType.EXCEPTION:
1376 
      x = TApplicationException()
1377 
      x.read(self._iprot)
1378 
      self._iprot.readMessageEnd()
1379 
      raise x
1380 
    result = getDefaultAddressId_result()
1381 
    result.read(self._iprot)
1382 
    self._iprot.readMessageEnd()
3431 rajveer 1383 
    if result.success is not None:
594 rajveer 1384 
      return result.success
3431 rajveer 1385 
    if result.ucx is not None:
594 rajveer 1386 
      raise result.ucx
1387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1388 
 
785 rajveer 1389 
  def getDefaultPincode(self, userId):
1390 
    """
1391 
    Parameters:
1392 
     - userId
1393 
    """
1394 
    self.send_getDefaultPincode(userId)
1395 
    return self.recv_getDefaultPincode()
1396 
 
1397 
  def send_getDefaultPincode(self, userId):
1398 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1399 
    args = getDefaultPincode_args()
1400 
    args.userId = userId
1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
1405 
  def recv_getDefaultPincode(self, ):
1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
1412 
    result = getDefaultPincode_result()
1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
3431 rajveer 1415 
    if result.success is not None:
785 rajveer 1416 
      return result.success
3431 rajveer 1417 
    if result.ucx is not None:
785 rajveer 1418 
      raise result.ucx
1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1420 
 
1274 varun.gupt 1421 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1422 
    """
1423 
    Parameters:
1424 
     - userId
1425 
     - replyTo
1426 
     - communicationType
1427 
     - orderId
1428 
     - airwaybillNo
1429 
     - productName
1430 
     - subject
1431 
     - message
1432 
    """
1433 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1434 
    return self.recv_saveUserCommunication()
1435 
 
1436 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1437 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1438 
    args = saveUserCommunication_args()
1439 
    args.userId = userId
1440 
    args.replyTo = replyTo
1441 
    args.communicationType = communicationType
1442 
    args.orderId = orderId
1443 
    args.airwaybillNo = airwaybillNo
1444 
    args.productName = productName
1445 
    args.subject = subject
1446 
    args.message = message
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_saveUserCommunication(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = saveUserCommunication_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
3431 rajveer 1461 
    if result.success is not None:
1274 varun.gupt 1462 
      return result.success
3431 rajveer 1463 
    if result.ucx is not None:
1274 varun.gupt 1464 
      raise result.ucx
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1466 
 
1590 varun.gupt 1467 
  def getUserCommunicationById(self, id):
1468 
    """
1469 
    Parameters:
1470 
     - id
1471 
    """
1472 
    self.send_getUserCommunicationById(id)
1473 
    return self.recv_getUserCommunicationById()
1474 
 
1475 
  def send_getUserCommunicationById(self, id):
1476 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1477 
    args = getUserCommunicationById_args()
1478 
    args.id = id
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getUserCommunicationById(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getUserCommunicationById_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
3431 rajveer 1493 
    if result.success is not None:
1590 varun.gupt 1494 
      return result.success
3431 rajveer 1495 
    if result.ucx is not None:
1590 varun.gupt 1496 
      raise result.ucx
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1498 
 
1499 
  def getUserCommunicationByUser(self, userId):
1500 
    """
1501 
    Parameters:
1502 
     - userId
1503 
    """
1504 
    self.send_getUserCommunicationByUser(userId)
1505 
    return self.recv_getUserCommunicationByUser()
1506 
 
1507 
  def send_getUserCommunicationByUser(self, userId):
1508 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1509 
    args = getUserCommunicationByUser_args()
1510 
    args.userId = userId
1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
1515 
  def recv_getUserCommunicationByUser(self, ):
1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
1522 
    result = getUserCommunicationByUser_result()
1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
3431 rajveer 1525 
    if result.success is not None:
1590 varun.gupt 1526 
      return result.success
3431 rajveer 1527 
    if result.ucx is not None:
1590 varun.gupt 1528 
      raise result.ucx
1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1530 
 
1531 
  def getAllUserCommunications(self, ):
1532 
    self.send_getAllUserCommunications()
1533 
    return self.recv_getAllUserCommunications()
1534 
 
1535 
  def send_getAllUserCommunications(self, ):
1536 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1537 
    args = getAllUserCommunications_args()
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getAllUserCommunications(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getAllUserCommunications_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
3431 rajveer 1552 
    if result.success is not None:
1590 varun.gupt 1553 
      return result.success
3431 rajveer 1554 
    if result.ucx is not None:
1590 varun.gupt 1555 
      raise result.ucx
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1557 
 
5407 amar.kumar 1558 
  def removeUserCommunication(self, id):
1559 
    """
1560 
    Parameters:
1561 
     - id
1562 
    """
1563 
    self.send_removeUserCommunication(id)
1564 
    self.recv_removeUserCommunication()
1565 
 
1566 
  def send_removeUserCommunication(self, id):
1567 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1568 
    args = removeUserCommunication_args()
1569 
    args.id = id
1570 
    args.write(self._oprot)
1571 
    self._oprot.writeMessageEnd()
1572 
    self._oprot.trans.flush()
1573 
 
1574 
  def recv_removeUserCommunication(self, ):
1575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1576 
    if mtype == TMessageType.EXCEPTION:
1577 
      x = TApplicationException()
1578 
      x.read(self._iprot)
1579 
      self._iprot.readMessageEnd()
1580 
      raise x
1581 
    result = removeUserCommunication_result()
1582 
    result.read(self._iprot)
1583 
    self._iprot.readMessageEnd()
1584 
    if result.ucx is not None:
1585 
      raise result.ucx
1586 
    return
1587 
 
1859 vikas 1588 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1589 
    """
1590 
    Parameters:
1591 
     - name
1859 vikas 1592 
     - addedOn
1845 vikas 1593 
    """
1859 vikas 1594 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1595 
    return self.recv_createMasterAffiliate()
1596 
 
1859 vikas 1597 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1598 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1599 
    args = createMasterAffiliate_args()
1600 
    args.name = name
1859 vikas 1601 
    args.addedOn = addedOn
1845 vikas 1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_createMasterAffiliate(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = createMasterAffiliate_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
1845 vikas 1617 
      return result.success
3431 rajveer 1618 
    if result.utx is not None:
1845 vikas 1619 
      raise result.utx
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1621 
 
1899 vikas 1622 
  def getAllMasterAffiliates(self, ):
1623 
    self.send_getAllMasterAffiliates()
1624 
    return self.recv_getAllMasterAffiliates()
1625 
 
1626 
  def send_getAllMasterAffiliates(self, ):
1627 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1628 
    args = getAllMasterAffiliates_args()
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getAllMasterAffiliates(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getAllMasterAffiliates_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
1899 vikas 1644 
      return result.success
3431 rajveer 1645 
    if result.utx is not None:
1899 vikas 1646 
      raise result.utx
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1648 
 
1845 vikas 1649 
  def getMasterAffiliateById(self, id):
1650 
    """
1651 
    Parameters:
1652 
     - id
1653 
    """
1654 
    self.send_getMasterAffiliateById(id)
1655 
    return self.recv_getMasterAffiliateById()
1656 
 
1657 
  def send_getMasterAffiliateById(self, id):
1658 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1659 
    args = getMasterAffiliateById_args()
1660 
    args.id = id
1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
1665 
  def recv_getMasterAffiliateById(self, ):
1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
1672 
    result = getMasterAffiliateById_result()
1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
1845 vikas 1676 
      return result.success
3431 rajveer 1677 
    if result.utx is not None:
1845 vikas 1678 
      raise result.utx
1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1680 
 
1681 
  def getMasterAffiliateByName(self, name):
1682 
    """
1683 
    Parameters:
1684 
     - name
1685 
    """
1686 
    self.send_getMasterAffiliateByName(name)
1687 
    return self.recv_getMasterAffiliateByName()
1688 
 
1689 
  def send_getMasterAffiliateByName(self, name):
1690 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1691 
    args = getMasterAffiliateByName_args()
1692 
    args.name = name
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getMasterAffiliateByName(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getMasterAffiliateByName_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
3431 rajveer 1707 
    if result.success is not None:
1845 vikas 1708 
      return result.success
3431 rajveer 1709 
    if result.utx is not None:
1845 vikas 1710 
      raise result.utx
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1712 
 
1859 vikas 1713 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1714 
    """
1715 
    Parameters:
1716 
     - name
1717 
     - url
1718 
     - masterAffiliateId
1859 vikas 1719 
     - addedOn
1845 vikas 1720 
    """
1859 vikas 1721 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1722 
    return self.recv_createAffiliate()
1723 
 
1859 vikas 1724 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1725 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1726 
    args = createAffiliate_args()
1727 
    args.name = name
1728 
    args.url = url
1729 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1730 
    args.addedOn = addedOn
1845 vikas 1731 
    args.write(self._oprot)
1732 
    self._oprot.writeMessageEnd()
1733 
    self._oprot.trans.flush()
1734 
 
1735 
  def recv_createAffiliate(self, ):
1736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1737 
    if mtype == TMessageType.EXCEPTION:
1738 
      x = TApplicationException()
1739 
      x.read(self._iprot)
1740 
      self._iprot.readMessageEnd()
1741 
      raise x
1742 
    result = createAffiliate_result()
1743 
    result.read(self._iprot)
1744 
    self._iprot.readMessageEnd()
3431 rajveer 1745 
    if result.success is not None:
1845 vikas 1746 
      return result.success
3431 rajveer 1747 
    if result.utx is not None:
1845 vikas 1748 
      raise result.utx
1749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1750 
 
1751 
  def getAffiliateById(self, id):
1752 
    """
1753 
    Parameters:
1754 
     - id
1755 
    """
1756 
    self.send_getAffiliateById(id)
1757 
    return self.recv_getAffiliateById()
1758 
 
1759 
  def send_getAffiliateById(self, id):
1760 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1761 
    args = getAffiliateById_args()
1762 
    args.id = id
1763 
    args.write(self._oprot)
1764 
    self._oprot.writeMessageEnd()
1765 
    self._oprot.trans.flush()
1766 
 
1767 
  def recv_getAffiliateById(self, ):
1768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1769 
    if mtype == TMessageType.EXCEPTION:
1770 
      x = TApplicationException()
1771 
      x.read(self._iprot)
1772 
      self._iprot.readMessageEnd()
1773 
      raise x
1774 
    result = getAffiliateById_result()
1775 
    result.read(self._iprot)
1776 
    self._iprot.readMessageEnd()
3431 rajveer 1777 
    if result.success is not None:
1845 vikas 1778 
      return result.success
3431 rajveer 1779 
    if result.utx is not None:
1845 vikas 1780 
      raise result.utx
1781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1782 
 
1783 
  def getAffiliateByName(self, name):
1784 
    """
1785 
    Parameters:
1786 
     - name
1787 
    """
1788 
    self.send_getAffiliateByName(name)
1789 
    return self.recv_getAffiliateByName()
1790 
 
1791 
  def send_getAffiliateByName(self, name):
1792 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1793 
    args = getAffiliateByName_args()
1794 
    args.name = name
1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1799 
  def recv_getAffiliateByName(self, ):
1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1806 
    result = getAffiliateByName_result()
1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
3431 rajveer 1809 
    if result.success is not None:
1845 vikas 1810 
      return result.success
3431 rajveer 1811 
    if result.utx is not None:
1845 vikas 1812 
      raise result.utx
1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1814 
 
1996 vikas 1815 
  def getTrackerById(self, id):
1845 vikas 1816 
    """
1817 
    Parameters:
1818 
     - id
1819 
    """
1996 vikas 1820 
    self.send_getTrackerById(id)
1845 vikas 1821 
    return self.recv_getTrackerById()
1822 
 
1996 vikas 1823 
  def send_getTrackerById(self, id):
1845 vikas 1824 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1825 
    args = getTrackerById_args()
1996 vikas 1826 
    args.id = id
1845 vikas 1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
1831 
  def recv_getTrackerById(self, ):
1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
1838 
    result = getTrackerById_result()
1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
3431 rajveer 1841 
    if result.success is not None:
1845 vikas 1842 
      return result.success
3431 rajveer 1843 
    if result.utx is not None:
1845 vikas 1844 
      raise result.utx
1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1846 
 
1996 vikas 1847 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1848 
    """
1849 
    Parameters:
1996 vikas 1850 
     - id
1845 vikas 1851 
    """
1996 vikas 1852 
    self.send_getAffiliatesByMasterAffiliate(id)
1853 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1854 
 
1996 vikas 1855 
  def send_getAffiliatesByMasterAffiliate(self, id):
1856 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1857 
    args = getAffiliatesByMasterAffiliate_args()
1858 
    args.id = id
1845 vikas 1859 
    args.write(self._oprot)
1860 
    self._oprot.writeMessageEnd()
1861 
    self._oprot.trans.flush()
1862 
 
1996 vikas 1863 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1865 
    if mtype == TMessageType.EXCEPTION:
1866 
      x = TApplicationException()
1867 
      x.read(self._iprot)
1868 
      self._iprot.readMessageEnd()
1869 
      raise x
1996 vikas 1870 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1871 
    result.read(self._iprot)
1872 
    self._iprot.readMessageEnd()
3431 rajveer 1873 
    if result.success is not None:
1845 vikas 1874 
      return result.success
3431 rajveer 1875 
    if result.utx is not None:
1845 vikas 1876 
      raise result.utx
1996 vikas 1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1878 
 
1996 vikas 1879 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1880 
    """
1881 
    Parameters:
1996 vikas 1882 
     - affiliateId
1845 vikas 1883 
     - userId
1884 
     - event
1885 
     - url
1886 
     - data
1859 vikas 1887 
     - addedOn
1845 vikas 1888 
    """
1996 vikas 1889 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1890 
    return self.recv_addTrackLog()
1891 
 
1996 vikas 1892 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1893 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1894 
    args = addTrackLog_args()
1996 vikas 1895 
    args.affiliateId = affiliateId
1845 vikas 1896 
    args.userId = userId
1897 
    args.event = event
1898 
    args.url = url
1899 
    args.data = data
1859 vikas 1900 
    args.addedOn = addedOn
1845 vikas 1901 
    args.write(self._oprot)
1902 
    self._oprot.writeMessageEnd()
1903 
    self._oprot.trans.flush()
1904 
 
1905 
  def recv_addTrackLog(self, ):
1906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1907 
    if mtype == TMessageType.EXCEPTION:
1908 
      x = TApplicationException()
1909 
      x.read(self._iprot)
1910 
      self._iprot.readMessageEnd()
1911 
      raise x
1912 
    result = addTrackLog_result()
1913 
    result.read(self._iprot)
1914 
    self._iprot.readMessageEnd()
3431 rajveer 1915 
    if result.success is not None:
1845 vikas 1916 
      return result.success
3431 rajveer 1917 
    if result.utx is not None:
1845 vikas 1918 
      raise result.utx
1919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1920 
 
1921 
  def getTrackLogById(self, id):
1922 
    """
1923 
    Parameters:
1924 
     - id
1925 
    """
1926 
    self.send_getTrackLogById(id)
1927 
    return self.recv_getTrackLogById()
1928 
 
1929 
  def send_getTrackLogById(self, id):
1930 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1931 
    args = getTrackLogById_args()
1932 
    args.id = id
1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
1937 
  def recv_getTrackLogById(self, ):
1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
1944 
    result = getTrackLogById_result()
1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
3431 rajveer 1947 
    if result.success is not None:
1845 vikas 1948 
      return result.success
3431 rajveer 1949 
    if result.utx is not None:
1845 vikas 1950 
      raise result.utx
1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1952 
 
3293 vikas 1953 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1954 
    """
1955 
    Parameters:
1996 vikas 1956 
     - affiliateId
3293 vikas 1957 
     - startDate
1958 
     - endDate
1845 vikas 1959 
    """
3293 vikas 1960 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1961 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1962 
 
3293 vikas 1963 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1964 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1965 
    args = getTrackLogsByAffiliate_args()
1966 
    args.affiliateId = affiliateId
3293 vikas 1967 
    args.startDate = startDate
1968 
    args.endDate = endDate
1845 vikas 1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1996 vikas 1973 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1996 vikas 1980 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
3431 rajveer 1983 
    if result.success is not None:
1845 vikas 1984 
      return result.success
3431 rajveer 1985 
    if result.utx is not None:
1845 vikas 1986 
      raise result.utx
1996 vikas 1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1988 
 
1989 
  def getTrackLogsByUser(self, userId):
1990 
    """
1991 
    Parameters:
1992 
     - userId
1993 
    """
1994 
    self.send_getTrackLogsByUser(userId)
1995 
    return self.recv_getTrackLogsByUser()
1996 
 
1997 
  def send_getTrackLogsByUser(self, userId):
1998 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1999 
    args = getTrackLogsByUser_args()
2000 
    args.userId = userId
2001 
    args.write(self._oprot)
2002 
    self._oprot.writeMessageEnd()
2003 
    self._oprot.trans.flush()
2004 
 
2005 
  def recv_getTrackLogsByUser(self, ):
2006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2007 
    if mtype == TMessageType.EXCEPTION:
2008 
      x = TApplicationException()
2009 
      x.read(self._iprot)
2010 
      self._iprot.readMessageEnd()
2011 
      raise x
2012 
    result = getTrackLogsByUser_result()
2013 
    result.read(self._iprot)
2014 
    self._iprot.readMessageEnd()
3431 rajveer 2015 
    if result.success is not None:
1845 vikas 2016 
      return result.success
3431 rajveer 2017 
    if result.utx is not None:
1845 vikas 2018 
      raise result.utx
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2020 
 
1996 vikas 2021 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2022 
    """
2023 
    Parameters:
2024 
     - userId
2025 
     - event
2026 
     - url
2027 
    """
1996 vikas 2028 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2029 
    return self.recv_getTrackLogs()
2030 
 
1996 vikas 2031 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2032 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2033 
    args = getTrackLogs_args()
2034 
    args.userId = userId
2035 
    args.event = event
2036 
    args.url = url
2037 
    args.write(self._oprot)
2038 
    self._oprot.writeMessageEnd()
2039 
    self._oprot.trans.flush()
2040 
 
2041 
  def recv_getTrackLogs(self, ):
2042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2043 
    if mtype == TMessageType.EXCEPTION:
2044 
      x = TApplicationException()
2045 
      x.read(self._iprot)
2046 
      self._iprot.readMessageEnd()
2047 
      raise x
2048 
    result = getTrackLogs_result()
2049 
    result.read(self._iprot)
2050 
    self._iprot.readMessageEnd()
3431 rajveer 2051 
    if result.success is not None:
1845 vikas 2052 
      return result.success
3431 rajveer 2053 
    if result.utx is not None:
1845 vikas 2054 
      raise result.utx
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2056 
 
559 chandransh 2057 
  def getCurrentCart(self, userId):
94 ashish 2058 
    """
2059 
    Parameters:
559 chandransh 2060 
     - userId
94 ashish 2061 
    """
559 chandransh 2062 
    self.send_getCurrentCart(userId)
2063 
    return self.recv_getCurrentCart()
94 ashish 2064 
 
559 chandransh 2065 
  def send_getCurrentCart(self, userId):
2066 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2067 
    args = getCurrentCart_args()
2068 
    args.userId = userId
94 ashish 2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
559 chandransh 2073 
  def recv_getCurrentCart(self, ):
94 ashish 2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
559 chandransh 2080 
    result = getCurrentCart_result()
94 ashish 2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
3431 rajveer 2083 
    if result.success is not None:
94 ashish 2084 
      return result.success
3431 rajveer 2085 
    if result.scx is not None:
559 chandransh 2086 
      raise result.scx
2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2088 
 
559 chandransh 2089 
  def getCart(self, cartId):
94 ashish 2090 
    """
2091 
    Parameters:
559 chandransh 2092 
     - cartId
94 ashish 2093 
    """
559 chandransh 2094 
    self.send_getCart(cartId)
2095 
    return self.recv_getCart()
94 ashish 2096 
 
559 chandransh 2097 
  def send_getCart(self, cartId):
2098 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2099 
    args = getCart_args()
2100 
    args.cartId = cartId
94 ashish 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
559 chandransh 2105 
  def recv_getCart(self, ):
94 ashish 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
559 chandransh 2112 
    result = getCart_result()
94 ashish 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
3431 rajveer 2115 
    if result.success is not None:
94 ashish 2116 
      return result.success
3431 rajveer 2117 
    if result.scx is not None:
559 chandransh 2118 
      raise result.scx
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2120 
 
559 chandransh 2121 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2122 
    """
2123 
    Parameters:
559 chandransh 2124 
     - from_time
2125 
     - to_time
2126 
     - status
94 ashish 2127 
    """
559 chandransh 2128 
    self.send_getCartsByTime(from_time, to_time, status)
2129 
    return self.recv_getCartsByTime()
94 ashish 2130 
 
559 chandransh 2131 
  def send_getCartsByTime(self, from_time, to_time, status):
2132 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2133 
    args = getCartsByTime_args()
2134 
    args.from_time = from_time
2135 
    args.to_time = to_time
2136 
    args.status = status
94 ashish 2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
559 chandransh 2141 
  def recv_getCartsByTime(self, ):
94 ashish 2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
559 chandransh 2148 
    result = getCartsByTime_result()
94 ashish 2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
3431 rajveer 2151 
    if result.success is not None:
94 ashish 2152 
      return result.success
3431 rajveer 2153 
    if result.scx is not None:
559 chandransh 2154 
      raise result.scx
2155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2156 
 
3557 rajveer 2157 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2158 
    """
2159 
    Parameters:
2160 
     - cartId
2161 
     - itemId
2162 
     - quantity
3557 rajveer 2163 
     - sourceId
559 chandransh 2164 
    """
3557 rajveer 2165 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2166 
    return self.recv_addItemToCart()
559 chandransh 2167 
 
3557 rajveer 2168 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2169 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2170 
    args = addItemToCart_args()
2171 
    args.cartId = cartId
2172 
    args.itemId = itemId
2173 
    args.quantity = quantity
3557 rajveer 2174 
    args.sourceId = sourceId
559 chandransh 2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
2179 
  def recv_addItemToCart(self, ):
2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
2186 
    result = addItemToCart_result()
2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
2035 rajveer 2190 
      return result.success
3431 rajveer 2191 
    if result.scx is not None:
559 chandransh 2192 
      raise result.scx
2035 rajveer 2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2194 
 
2195 
  def deleteItemFromCart(self, cartId, itemId):
2196 
    """
2197 
    Parameters:
2198 
     - cartId
2199 
     - itemId
2200 
    """
2201 
    self.send_deleteItemFromCart(cartId, itemId)
2202 
    self.recv_deleteItemFromCart()
2203 
 
2204 
  def send_deleteItemFromCart(self, cartId, itemId):
2205 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2206 
    args = deleteItemFromCart_args()
2207 
    args.cartId = cartId
2208 
    args.itemId = itemId
2209 
    args.write(self._oprot)
2210 
    self._oprot.writeMessageEnd()
2211 
    self._oprot.trans.flush()
2212 
 
2213 
  def recv_deleteItemFromCart(self, ):
2214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2215 
    if mtype == TMessageType.EXCEPTION:
2216 
      x = TApplicationException()
2217 
      x.read(self._iprot)
2218 
      self._iprot.readMessageEnd()
2219 
      raise x
2220 
    result = deleteItemFromCart_result()
2221 
    result.read(self._iprot)
2222 
    self._iprot.readMessageEnd()
3431 rajveer 2223 
    if result.scx is not None:
559 chandransh 2224 
      raise result.scx
2225 
    return
2226 
 
2227 
  def addAddressToCart(self, cartId, addressId):
2228 
    """
2229 
    Parameters:
2230 
     - cartId
2231 
     - addressId
2232 
    """
2233 
    self.send_addAddressToCart(cartId, addressId)
2234 
    self.recv_addAddressToCart()
2235 
 
2236 
  def send_addAddressToCart(self, cartId, addressId):
2237 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2238 
    args = addAddressToCart_args()
2239 
    args.cartId = cartId
2240 
    args.addressId = addressId
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_addAddressToCart(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = addAddressToCart_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
3431 rajveer 2255 
    if result.scx is not None:
575 chandransh 2256 
      raise result.scx
559 chandransh 2257 
    return
2258 
 
5553 rajveer 2259 
  def addStoreToCart(self, cartId, storeId):
2260 
    """
2261 
    Parameters:
2262 
     - cartId
2263 
     - storeId
2264 
    """
2265 
    self.send_addStoreToCart(cartId, storeId)
2266 
    self.recv_addStoreToCart()
2267 
 
2268 
  def send_addStoreToCart(self, cartId, storeId):
2269 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2270 
    args = addStoreToCart_args()
2271 
    args.cartId = cartId
2272 
    args.storeId = storeId
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_addStoreToCart(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = addStoreToCart_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.scx is not None:
2288 
      raise result.scx
2289 
    return
2290 
 
6922 anupam.sin 2291 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2292 
    """
2293 
    Parameters:
6922 anupam.sin 2294 
     - cart
1976 varun.gupt 2295 
     - couponCode
2296 
    """
6922 anupam.sin 2297 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2298 
    self.recv_applyCouponToCart()
2299 
 
6922 anupam.sin 2300 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2301 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2302 
    args = applyCouponToCart_args()
6922 anupam.sin 2303 
    args.cart = cart
1976 varun.gupt 2304 
    args.couponCode = couponCode
2305 
    args.write(self._oprot)
2306 
    self._oprot.writeMessageEnd()
2307 
    self._oprot.trans.flush()
2308 
 
2309 
  def recv_applyCouponToCart(self, ):
2310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2311 
    if mtype == TMessageType.EXCEPTION:
2312 
      x = TApplicationException()
2313 
      x.read(self._iprot)
2314 
      self._iprot.readMessageEnd()
2315 
      raise x
2316 
    result = applyCouponToCart_result()
2317 
    result.read(self._iprot)
2318 
    self._iprot.readMessageEnd()
3431 rajveer 2319 
    if result.scx is not None:
1976 varun.gupt 2320 
      raise result.scx
2321 
    return
2322 
 
2323 
  def removeCoupon(self, cartId):
2324 
    """
2325 
    Parameters:
2326 
     - cartId
2327 
    """
2328 
    self.send_removeCoupon(cartId)
2329 
    self.recv_removeCoupon()
2330 
 
2331 
  def send_removeCoupon(self, cartId):
2332 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2333 
    args = removeCoupon_args()
2334 
    args.cartId = cartId
2335 
    args.write(self._oprot)
2336 
    self._oprot.writeMessageEnd()
2337 
    self._oprot.trans.flush()
2338 
 
2339 
  def recv_removeCoupon(self, ):
2340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2341 
    if mtype == TMessageType.EXCEPTION:
2342 
      x = TApplicationException()
2343 
      x.read(self._iprot)
2344 
      self._iprot.readMessageEnd()
2345 
      raise x
2346 
    result = removeCoupon_result()
2347 
    result.read(self._iprot)
2348 
    self._iprot.readMessageEnd()
3431 rajveer 2349 
    if result.scx is not None:
1976 varun.gupt 2350 
      raise result.scx
2351 
    return
2352 
 
3554 varun.gupt 2353 
  def deleteDiscountsFromCart(self, cartId):
2354 
    """
2355 
    Deletes all the discounts associated with the cart
2356 
 
2357 
    Parameters:
2358 
     - cartId
2359 
    """
2360 
    self.send_deleteDiscountsFromCart(cartId)
2361 
    self.recv_deleteDiscountsFromCart()
2362 
 
2363 
  def send_deleteDiscountsFromCart(self, cartId):
2364 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2365 
    args = deleteDiscountsFromCart_args()
2366 
    args.cartId = cartId
2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
2371 
  def recv_deleteDiscountsFromCart(self, ):
2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
2378 
    result = deleteDiscountsFromCart_result()
2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
2381 
    if result.scx is not None:
2382 
      raise result.scx
2383 
    return
2384 
 
2385 
  def saveDiscounts(self, discounts):
2386 
    """
2387 
    Accepts a list of thrift objects of Discount type and saves them
2388 
 
2389 
    Parameters:
2390 
     - discounts
2391 
    """
2392 
    self.send_saveDiscounts(discounts)
2393 
    self.recv_saveDiscounts()
2394 
 
2395 
  def send_saveDiscounts(self, discounts):
2396 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2397 
    args = saveDiscounts_args()
2398 
    args.discounts = discounts
2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
2403 
  def recv_saveDiscounts(self, ):
2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
2410 
    result = saveDiscounts_result()
2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
2413 
    if result.scx is not None:
2414 
      raise result.scx
2415 
    return
2416 
 
11526 amit.gupta 2417 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2418 
    """
690 chandransh 2419 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2420 
 
559 chandransh 2421 
    Parameters:
2422 
     - cartId
2815 vikas 2423 
     - sessionSource
2424 
     - sessionStartTime
3858 vikas 2425 
     - firstSource
2426 
     - firstSourceTime
5326 rajveer 2427 
     - userId
6389 rajveer 2428 
     - schemeId
11526 amit.gupta 2429 
     - orderSource
559 chandransh 2430 
    """
11526 amit.gupta 2431 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2432 
    return self.recv_createOrders()
559 chandransh 2433 
 
11526 amit.gupta 2434 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2435 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2436 
    args = createOrders_args()
559 chandransh 2437 
    args.cartId = cartId
2815 vikas 2438 
    args.sessionSource = sessionSource
2439 
    args.sessionStartTime = sessionStartTime
3858 vikas 2440 
    args.firstSource = firstSource
2441 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2442 
    args.userId = userId
6389 rajveer 2443 
    args.schemeId = schemeId
11526 amit.gupta 2444 
    args.orderSource = orderSource
559 chandransh 2445 
    args.write(self._oprot)
2446 
    self._oprot.writeMessageEnd()
2447 
    self._oprot.trans.flush()
2448 
 
690 chandransh 2449 
  def recv_createOrders(self, ):
559 chandransh 2450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2451 
    if mtype == TMessageType.EXCEPTION:
2452 
      x = TApplicationException()
2453 
      x.read(self._iprot)
2454 
      self._iprot.readMessageEnd()
2455 
      raise x
690 chandransh 2456 
    result = createOrders_result()
559 chandransh 2457 
    result.read(self._iprot)
2458 
    self._iprot.readMessageEnd()
3431 rajveer 2459 
    if result.success is not None:
130 ashish 2460 
      return result.success
3431 rajveer 2461 
    if result.scx is not None:
559 chandransh 2462 
      raise result.scx
690 chandransh 2463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2464 
 
3557 rajveer 2465 
  def validateCart(self, cartId, sourceId):
130 ashish 2466 
    """
690 chandransh 2467 
    Validates that:
2468 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2469 
    2. All of the lines in the cart are active items.
690 chandransh 2470 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2471 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2472 
 
130 ashish 2473 
    Parameters:
559 chandransh 2474 
     - cartId
3557 rajveer 2475 
     - sourceId
130 ashish 2476 
    """
3557 rajveer 2477 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2478 
    return self.recv_validateCart()
130 ashish 2479 
 
3557 rajveer 2480 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2481 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2482 
    args = validateCart_args()
2483 
    args.cartId = cartId
3557 rajveer 2484 
    args.sourceId = sourceId
130 ashish 2485 
    args.write(self._oprot)
2486 
    self._oprot.writeMessageEnd()
2487 
    self._oprot.trans.flush()
2488 
 
559 chandransh 2489 
  def recv_validateCart(self, ):
130 ashish 2490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2491 
    if mtype == TMessageType.EXCEPTION:
2492 
      x = TApplicationException()
2493 
      x.read(self._iprot)
2494 
      self._iprot.readMessageEnd()
2495 
      raise x
559 chandransh 2496 
    result = validateCart_result()
130 ashish 2497 
    result.read(self._iprot)
2498 
    self._iprot.readMessageEnd()
3431 rajveer 2499 
    if result.success is not None:
130 ashish 2500 
      return result.success
3431 rajveer 2501 
    if result.scex is not None:
575 chandransh 2502 
      raise result.scex
559 chandransh 2503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2504 
 
11980 amit.gupta 2505 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2506 
    """
2507 
    Validates that:
2508 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2509 
    2. All of the lines in the cart are active items.
2510 
    3. The estimate for any of the lines in cart doesn't change.
2511 
    If all three are true, returns empty string; else returns appropriate message.
2512 
 
2513 
    Parameters:
2514 
     - cartId
2515 
     - sourceId
2516 
     - dealCoupon
2517 
    """
2518 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2519 
    return self.recv_validateCartWithDealerCoupon()
2520 
 
2521 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2522 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2523 
    args = validateCartWithDealerCoupon_args()
2524 
    args.cartId = cartId
2525 
    args.sourceId = sourceId
2526 
    args.dealCoupon = dealCoupon
2527 
    args.write(self._oprot)
2528 
    self._oprot.writeMessageEnd()
2529 
    self._oprot.trans.flush()
2530 
 
2531 
  def recv_validateCartWithDealerCoupon(self, ):
2532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2533 
    if mtype == TMessageType.EXCEPTION:
2534 
      x = TApplicationException()
2535 
      x.read(self._iprot)
2536 
      self._iprot.readMessageEnd()
2537 
      raise x
2538 
    result = validateCartWithDealerCoupon_result()
2539 
    result.read(self._iprot)
2540 
    self._iprot.readMessageEnd()
2541 
    if result.success is not None:
2542 
      return result.success
2543 
    if result.scex is not None:
2544 
      raise result.scex
2545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2546 
 
690 chandransh 2547 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2548 
    """
690 chandransh 2549 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2550 
 
575 chandransh 2551 
    Parameters:
690 chandransh 2552 
     - fromCartId
2553 
     - toCartId
2554 
    """
2555 
    self.send_mergeCart(fromCartId, toCartId)
2556 
    self.recv_mergeCart()
2557 
 
2558 
  def send_mergeCart(self, fromCartId, toCartId):
2559 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2560 
    args = mergeCart_args()
2561 
    args.fromCartId = fromCartId
2562 
    args.toCartId = toCartId
2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
2567 
  def recv_mergeCart(self, ):
2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
2574 
    result = mergeCart_result()
2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
2577 
    return
2578 
 
2579 
  def checkOut(self, cartId):
2580 
    """
2581 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2582 
 
690 chandransh 2583 
    Parameters:
575 chandransh 2584 
     - cartId
2585 
    """
690 chandransh 2586 
    self.send_checkOut(cartId)
2587 
    return self.recv_checkOut()
575 chandransh 2588 
 
690 chandransh 2589 
  def send_checkOut(self, cartId):
2590 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2591 
    args = checkOut_args()
575 chandransh 2592 
    args.cartId = cartId
2593 
    args.write(self._oprot)
2594 
    self._oprot.writeMessageEnd()
2595 
    self._oprot.trans.flush()
2596 
 
690 chandransh 2597 
  def recv_checkOut(self, ):
575 chandransh 2598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2599 
    if mtype == TMessageType.EXCEPTION:
2600 
      x = TApplicationException()
2601 
      x.read(self._iprot)
2602 
      self._iprot.readMessageEnd()
2603 
      raise x
690 chandransh 2604 
    result = checkOut_result()
575 chandransh 2605 
    result.read(self._iprot)
2606 
    self._iprot.readMessageEnd()
3431 rajveer 2607 
    if result.success is not None:
575 chandransh 2608 
      return result.success
3431 rajveer 2609 
    if result.scex is not None:
575 chandransh 2610 
      raise result.scex
690 chandransh 2611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2612 
 
690 chandransh 2613 
  def resetCart(self, cartId, items):
559 chandransh 2614 
    """
690 chandransh 2615 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2616 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2617 
 
559 chandransh 2618 
    Parameters:
690 chandransh 2619 
     - cartId
2620 
     - items
559 chandransh 2621 
    """
690 chandransh 2622 
    self.send_resetCart(cartId, items)
2623 
    return self.recv_resetCart()
130 ashish 2624 
 
690 chandransh 2625 
  def send_resetCart(self, cartId, items):
2626 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2627 
    args = resetCart_args()
2628 
    args.cartId = cartId
2629 
    args.items = items
559 chandransh 2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
690 chandransh 2634 
  def recv_resetCart(self, ):
559 chandransh 2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
690 chandransh 2641 
    result = resetCart_result()
559 chandransh 2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
3431 rajveer 2644 
    if result.success is not None:
690 chandransh 2645 
      return result.success
3431 rajveer 2646 
    if result.scex is not None:
690 chandransh 2647 
      raise result.scex
2648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2649 
 
2981 rajveer 2650 
  def getUserCount(self, userType):
559 chandransh 2651 
    """
2981 rajveer 2652 
    Returns number of registered users.
2653 
    If userType = null, then it returns count of all users, including anonymous
2654 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2655 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2656 
 
559 chandransh 2657 
    Parameters:
2981 rajveer 2658 
     - userType
559 chandransh 2659 
    """
2981 rajveer 2660 
    self.send_getUserCount(userType)
2661 
    return self.recv_getUserCount()
559 chandransh 2662 
 
2981 rajveer 2663 
  def send_getUserCount(self, userType):
2664 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2665 
    args = getUserCount_args()
2666 
    args.userType = userType
559 chandransh 2667 
    args.write(self._oprot)
2668 
    self._oprot.writeMessageEnd()
2669 
    self._oprot.trans.flush()
2670 
 
2981 rajveer 2671 
  def recv_getUserCount(self, ):
559 chandransh 2672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2673 
    if mtype == TMessageType.EXCEPTION:
2674 
      x = TApplicationException()
2675 
      x.read(self._iprot)
2676 
      self._iprot.readMessageEnd()
2677 
      raise x
2981 rajveer 2678 
    result = getUserCount_result()
559 chandransh 2679 
    result.read(self._iprot)
2680 
    self._iprot.readMessageEnd()
3431 rajveer 2681 
    if result.success is not None:
559 chandransh 2682 
      return result.success
2981 rajveer 2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2684 
 
2981 rajveer 2685 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2686 
    """
2981 rajveer 2687 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2688 
    If any of startDate or endDate is -1, then that filter is ignored.
2689 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2690 
 
2691 
 
559 chandransh 2692 
    Parameters:
2981 rajveer 2693 
     - userType
2694 
     - startDate
2695 
     - endDate
559 chandransh 2696 
    """
2981 rajveer 2697 
    self.send_getAllUsers(userType, startDate, endDate)
2698 
    return self.recv_getAllUsers()
559 chandransh 2699 
 
2981 rajveer 2700 
  def send_getAllUsers(self, userType, startDate, endDate):
2701 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2702 
    args = getAllUsers_args()
2703 
    args.userType = userType
2704 
    args.startDate = startDate
2705 
    args.endDate = endDate
559 chandransh 2706 
    args.write(self._oprot)
2707 
    self._oprot.writeMessageEnd()
2708 
    self._oprot.trans.flush()
2709 
 
2981 rajveer 2710 
  def recv_getAllUsers(self, ):
559 chandransh 2711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2712 
    if mtype == TMessageType.EXCEPTION:
2713 
      x = TApplicationException()
2714 
      x.read(self._iprot)
2715 
      self._iprot.readMessageEnd()
2716 
      raise x
2981 rajveer 2717 
    result = getAllUsers_result()
559 chandransh 2718 
    result.read(self._iprot)
2719 
    self._iprot.readMessageEnd()
3431 rajveer 2720 
    if result.success is not None:
559 chandransh 2721 
      return result.success
2981 rajveer 2722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2723 
 
2981 rajveer 2724 
  def getMyResearchItems(self, userId):
559 chandransh 2725 
    """
2981 rajveer 2726 
    Returns list of item ids in myresearch for the user
3431 rajveer 2727 
 
559 chandransh 2728 
    Parameters:
772 rajveer 2729 
     - userId
559 chandransh 2730 
    """
2981 rajveer 2731 
    self.send_getMyResearchItems(userId)
2732 
    return self.recv_getMyResearchItems()
559 chandransh 2733 
 
2981 rajveer 2734 
  def send_getMyResearchItems(self, userId):
2735 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2736 
    args = getMyResearchItems_args()
772 rajveer 2737 
    args.userId = userId
559 chandransh 2738 
    args.write(self._oprot)
2739 
    self._oprot.writeMessageEnd()
2740 
    self._oprot.trans.flush()
2741 
 
2981 rajveer 2742 
  def recv_getMyResearchItems(self, ):
559 chandransh 2743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2744 
    if mtype == TMessageType.EXCEPTION:
2745 
      x = TApplicationException()
2746 
      x.read(self._iprot)
2747 
      self._iprot.readMessageEnd()
2748 
      raise x
2981 rajveer 2749 
    result = getMyResearchItems_result()
559 chandransh 2750 
    result.read(self._iprot)
2751 
    self._iprot.readMessageEnd()
3431 rajveer 2752 
    if result.success is not None:
559 chandransh 2753 
      return result.success
3431 rajveer 2754 
    if result.scx is not None:
559 chandransh 2755 
      raise result.scx
2981 rajveer 2756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2757 
 
2981 rajveer 2758 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2759 
    """
2981 rajveer 2760 
    add item to my research for a user
3431 rajveer 2761 
 
559 chandransh 2762 
    Parameters:
2981 rajveer 2763 
     - userId
2764 
     - itemId
559 chandransh 2765 
    """
2981 rajveer 2766 
    self.send_updateMyResearch(userId, itemId)
2767 
    return self.recv_updateMyResearch()
559 chandransh 2768 
 
2981 rajveer 2769 
  def send_updateMyResearch(self, userId, itemId):
2770 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2771 
    args = updateMyResearch_args()
2772 
    args.userId = userId
2773 
    args.itemId = itemId
559 chandransh 2774 
    args.write(self._oprot)
2775 
    self._oprot.writeMessageEnd()
2776 
    self._oprot.trans.flush()
2777 
 
2981 rajveer 2778 
  def recv_updateMyResearch(self, ):
559 chandransh 2779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2780 
    if mtype == TMessageType.EXCEPTION:
2781 
      x = TApplicationException()
2782 
      x.read(self._iprot)
2783 
      self._iprot.readMessageEnd()
2784 
      raise x
2981 rajveer 2785 
    result = updateMyResearch_result()
559 chandransh 2786 
    result.read(self._iprot)
2787 
    self._iprot.readMessageEnd()
3431 rajveer 2788 
    if result.success is not None:
2981 rajveer 2789 
      return result.success
3431 rajveer 2790 
    if result.scx is not None:
2981 rajveer 2791 
      raise result.scx
2792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2793 
 
2981 rajveer 2794 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2795 
    """
2981 rajveer 2796 
    delete item from my research for a user
3431 rajveer 2797 
 
1596 ankur.sing 2798 
    Parameters:
2981 rajveer 2799 
     - userId
2800 
     - itemId
1596 ankur.sing 2801 
    """
2981 rajveer 2802 
    self.send_deleteItemFromMyResearch(userId, itemId)
2803 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2804 
 
2981 rajveer 2805 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2806 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2807 
    args = deleteItemFromMyResearch_args()
2808 
    args.userId = userId
2809 
    args.itemId = itemId
1596 ankur.sing 2810 
    args.write(self._oprot)
2811 
    self._oprot.writeMessageEnd()
2812 
    self._oprot.trans.flush()
2813 
 
2981 rajveer 2814 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2816 
    if mtype == TMessageType.EXCEPTION:
2817 
      x = TApplicationException()
2818 
      x.read(self._iprot)
2819 
      self._iprot.readMessageEnd()
2820 
      raise x
2981 rajveer 2821 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2822 
    result.read(self._iprot)
2823 
    self._iprot.readMessageEnd()
3431 rajveer 2824 
    if result.scx is not None:
2981 rajveer 2825 
      raise result.scx
2826 
    return
1596 ankur.sing 2827 
 
2981 rajveer 2828 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2829 
    """
2981 rajveer 2830 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2831 
 
1673 ankur.sing 2832 
    Parameters:
2981 rajveer 2833 
     - userId
1673 ankur.sing 2834 
    """
2981 rajveer 2835 
    self.send_getBrowseHistoryItems(userId)
2836 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2837 
 
2981 rajveer 2838 
  def send_getBrowseHistoryItems(self, userId):
2839 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2840 
    args = getBrowseHistoryItems_args()
2841 
    args.userId = userId
1673 ankur.sing 2842 
    args.write(self._oprot)
2843 
    self._oprot.writeMessageEnd()
2844 
    self._oprot.trans.flush()
2845 
 
2981 rajveer 2846 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2848 
    if mtype == TMessageType.EXCEPTION:
2849 
      x = TApplicationException()
2850 
      x.read(self._iprot)
2851 
      self._iprot.readMessageEnd()
2852 
      raise x
2981 rajveer 2853 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2854 
    result.read(self._iprot)
2855 
    self._iprot.readMessageEnd()
3431 rajveer 2856 
    if result.success is not None:
1673 ankur.sing 2857 
      return result.success
3431 rajveer 2858 
    if result.scx is not None:
2981 rajveer 2859 
      raise result.scx
2860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2861 
 
2981 rajveer 2862 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2863 
    """
2981 rajveer 2864 
    add item to browse history for a user
3431 rajveer 2865 
 
2642 varun.gupt 2866 
    Parameters:
2981 rajveer 2867 
     - userId
2868 
     - itemId
2642 varun.gupt 2869 
    """
2981 rajveer 2870 
    self.send_updateBrowseHistory(userId, itemId)
2871 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2872 
 
2981 rajveer 2873 
  def send_updateBrowseHistory(self, userId, itemId):
2874 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2875 
    args = updateBrowseHistory_args()
2876 
    args.userId = userId
2877 
    args.itemId = itemId
2642 varun.gupt 2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2981 rajveer 2882 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2981 rajveer 2889 
    result = updateBrowseHistory_result()
2642 varun.gupt 2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    return
2893 
 
3385 varun.gupt 2894 
  def getCartsWithCouponCount(self, couponCode):
2895 
    """
2896 
    Returns count of Carts with given coupon applied
3431 rajveer 2897 
 
3385 varun.gupt 2898 
    Parameters:
2899 
     - couponCode
2900 
    """
2901 
    self.send_getCartsWithCouponCount(couponCode)
2902 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2903 
 
3385 varun.gupt 2904 
  def send_getCartsWithCouponCount(self, couponCode):
2905 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2906 
    args = getCartsWithCouponCount_args()
2907 
    args.couponCode = couponCode
2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
2911 
 
2912 
  def recv_getCartsWithCouponCount(self, ):
2913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2914 
    if mtype == TMessageType.EXCEPTION:
2915 
      x = TApplicationException()
2916 
      x.read(self._iprot)
2917 
      self._iprot.readMessageEnd()
2918 
      raise x
2919 
    result = getCartsWithCouponCount_result()
2920 
    result.read(self._iprot)
2921 
    self._iprot.readMessageEnd()
3431 rajveer 2922 
    if result.success is not None:
3385 varun.gupt 2923 
      return result.success
2924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2925 
 
3499 mandeep.dh 2926 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2927 
    """
2928 
    Updates COD trust level of a user
3385 varun.gupt 2929 
 
3499 mandeep.dh 2930 
    Parameters:
2931 
     - userId
2932 
     - trustLevelDelta
2933 
    """
2934 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2935 
 
2936 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2937 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2938 
    args = increaseTrustLevel_args()
2939 
    args.userId = userId
2940 
    args.trustLevelDelta = trustLevelDelta
2941 
    args.write(self._oprot)
2942 
    self._oprot.writeMessageEnd()
2943 
    self._oprot.trans.flush()
5407 amar.kumar 2944 
  def getTrustLevel(self, userId):
2945 
    """
2946 
    Get trust level of a user
2947 
 
2948 
    Parameters:
2949 
     - userId
2950 
    """
2951 
    self.send_getTrustLevel(userId)
2952 
    return self.recv_getTrustLevel()
2953 
 
2954 
  def send_getTrustLevel(self, userId):
2955 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2956 
    args = getTrustLevel_args()
2957 
    args.userId = userId
2958 
    args.write(self._oprot)
2959 
    self._oprot.writeMessageEnd()
2960 
    self._oprot.trans.flush()
2961 
 
2962 
  def recv_getTrustLevel(self, ):
2963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2964 
    if mtype == TMessageType.EXCEPTION:
2965 
      x = TApplicationException()
2966 
      x.read(self._iprot)
2967 
      self._iprot.readMessageEnd()
2968 
      raise x
2969 
    result = getTrustLevel_result()
2970 
    result.read(self._iprot)
2971 
    self._iprot.readMessageEnd()
2972 
    if result.success is not None:
2973 
      return result.success
2974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
2975 
 
4668 varun.gupt 2976 
  def showCODOption(self, cartId, sourceId, pincode):
2977 
    """
2978 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 2979 
 
4668 varun.gupt 2980 
    Parameters:
2981 
     - cartId
2982 
     - sourceId
2983 
     - pincode
2984 
    """
2985 
    self.send_showCODOption(cartId, sourceId, pincode)
2986 
    return self.recv_showCODOption()
2987 
 
2988 
  def send_showCODOption(self, cartId, sourceId, pincode):
2989 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
2990 
    args = showCODOption_args()
2991 
    args.cartId = cartId
2992 
    args.sourceId = sourceId
2993 
    args.pincode = pincode
2994 
    args.write(self._oprot)
2995 
    self._oprot.writeMessageEnd()
2996 
    self._oprot.trans.flush()
2997 
 
2998 
  def recv_showCODOption(self, ):
2999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3000 
    if mtype == TMessageType.EXCEPTION:
3001 
      x = TApplicationException()
3002 
      x.read(self._iprot)
3003 
      self._iprot.readMessageEnd()
3004 
      raise x
3005 
    result = showCODOption_result()
3006 
    result.read(self._iprot)
3007 
    self._iprot.readMessageEnd()
3008 
    if result.success is not None:
3009 
      return result.success
3010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3011 
 
5623 anupam.sin 3012 
  def getUserEmails(self, startDate, endDate):
3013 
    """
3014 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3015 
 
5623 anupam.sin 3016 
    Parameters:
3017 
     - startDate
3018 
     - endDate
3019 
    """
3020 
    self.send_getUserEmails(startDate, endDate)
3021 
    return self.recv_getUserEmails()
3022 
 
3023 
  def send_getUserEmails(self, startDate, endDate):
3024 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3025 
    args = getUserEmails_args()
3026 
    args.startDate = startDate
3027 
    args.endDate = endDate
3028 
    args.write(self._oprot)
3029 
    self._oprot.writeMessageEnd()
3030 
    self._oprot.trans.flush()
3031 
 
3032 
  def recv_getUserEmails(self, ):
3033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3034 
    if mtype == TMessageType.EXCEPTION:
3035 
      x = TApplicationException()
3036 
      x.read(self._iprot)
3037 
      self._iprot.readMessageEnd()
3038 
      raise x
3039 
    result = getUserEmails_result()
3040 
    result.read(self._iprot)
3041 
    self._iprot.readMessageEnd()
3042 
    if result.success is not None:
3043 
      return result.success
3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3045 
 
9299 kshitij.so 3046 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3047 
    """
3048 
    Mark a cart lineitem as insured. Returns true/false.
3049 
 
3050 
    Parameters:
3051 
     - itemId
3052 
     - cartId
3053 
     - toInsure
9299 kshitij.so 3054 
     - insurerType
6903 anupam.sin 3055 
    """
9299 kshitij.so 3056 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3057 
    return self.recv_insureItem()
3058 
 
9299 kshitij.so 3059 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3060 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3061 
    args = insureItem_args()
3062 
    args.itemId = itemId
3063 
    args.cartId = cartId
3064 
    args.toInsure = toInsure
9299 kshitij.so 3065 
    args.insurerType = insurerType
6903 anupam.sin 3066 
    args.write(self._oprot)
3067 
    self._oprot.writeMessageEnd()
3068 
    self._oprot.trans.flush()
3069 
 
3070 
  def recv_insureItem(self, ):
3071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3072 
    if mtype == TMessageType.EXCEPTION:
3073 
      x = TApplicationException()
3074 
      x.read(self._iprot)
3075 
      self._iprot.readMessageEnd()
3076 
      raise x
3077 
    result = insureItem_result()
3078 
    result.read(self._iprot)
3079 
    self._iprot.readMessageEnd()
3080 
    if result.success is not None:
3081 
      return result.success
3082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3083 
 
3084 
  def cancelInsurance(self, cartId):
3085 
    """
3086 
    Cancel insurance for all items in the cart
3087 
 
3088 
    Parameters:
3089 
     - cartId
3090 
    """
3091 
    self.send_cancelInsurance(cartId)
3092 
    return self.recv_cancelInsurance()
3093 
 
3094 
  def send_cancelInsurance(self, cartId):
3095 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3096 
    args = cancelInsurance_args()
3097 
    args.cartId = cartId
3098 
    args.write(self._oprot)
3099 
    self._oprot.writeMessageEnd()
3100 
    self._oprot.trans.flush()
3101 
 
3102 
  def recv_cancelInsurance(self, ):
3103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3104 
    if mtype == TMessageType.EXCEPTION:
3105 
      x = TApplicationException()
3106 
      x.read(self._iprot)
3107 
      self._iprot.readMessageEnd()
3108 
      raise x
3109 
    result = cancelInsurance_result()
3110 
    result.read(self._iprot)
3111 
    self._iprot.readMessageEnd()
3112 
    if result.success is not None:
3113 
      return result.success
3114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3115 
 
3116 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3117 
    """
3118 
    Stores insurance specific details like date of birth and guardianName
3119 
 
3120 
    Parameters:
3121 
     - addressId
3122 
     - dob
3123 
     - guardianName
3124 
    """
3125 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3126 
    return self.recv_storeInsuranceSpecificDetails()
3127 
 
3128 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3129 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3130 
    args = storeInsuranceSpecificDetails_args()
3131 
    args.addressId = addressId
3132 
    args.dob = dob
3133 
    args.guardianName = guardianName
3134 
    args.write(self._oprot)
3135 
    self._oprot.writeMessageEnd()
3136 
    self._oprot.trans.flush()
3137 
 
3138 
  def recv_storeInsuranceSpecificDetails(self, ):
3139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3140 
    if mtype == TMessageType.EXCEPTION:
3141 
      x = TApplicationException()
3142 
      x.read(self._iprot)
3143 
      self._iprot.readMessageEnd()
3144 
      raise x
3145 
    result = storeInsuranceSpecificDetails_result()
3146 
    result.read(self._iprot)
3147 
    self._iprot.readMessageEnd()
3148 
    if result.success is not None:
3149 
      return result.success
3150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3151 
 
3152 
  def isInsuranceDetailPresent(self, addressId):
3153 
    """
3154 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3155 
 
3156 
    Parameters:
3157 
     - addressId
3158 
    """
3159 
    self.send_isInsuranceDetailPresent(addressId)
3160 
    return self.recv_isInsuranceDetailPresent()
3161 
 
3162 
  def send_isInsuranceDetailPresent(self, addressId):
3163 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3164 
    args = isInsuranceDetailPresent_args()
3165 
    args.addressId = addressId
3166 
    args.write(self._oprot)
3167 
    self._oprot.writeMessageEnd()
3168 
    self._oprot.trans.flush()
3169 
 
3170 
  def recv_isInsuranceDetailPresent(self, ):
3171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3172 
    if mtype == TMessageType.EXCEPTION:
3173 
      x = TApplicationException()
3174 
      x.read(self._iprot)
3175 
      self._iprot.readMessageEnd()
3176 
      raise x
3177 
    result = isInsuranceDetailPresent_result()
3178 
    result.read(self._iprot)
3179 
    self._iprot.readMessageEnd()
3180 
    if result.success is not None:
3181 
      return result.success
3182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3183 
 
9791 rajveer 3184 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3185 
    """
9791 rajveer 3186 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3187 
 
6821 amar.kumar 3188 
    Parameters:
3189 
     - startDate
3190 
     - endDate
3191 
    """
9791 rajveer 3192 
    self.send_getProductsAddedToCart(startDate, endDate)
3193 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3194 
 
9791 rajveer 3195 
  def send_getProductsAddedToCart(self, startDate, endDate):
3196 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3197 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3198 
    args.startDate = startDate
3199 
    args.endDate = endDate
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
9791 rajveer 3204 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
9791 rajveer 3211 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3214 
    if result.success is not None:
3215 
      return result.success
9791 rajveer 3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3217 
 
11980 amit.gupta 3218 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3219 
    """
3220 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3221 
 
11592 amit.gupta 3222 
    Parameters:
3223 
     - cartId
3224 
     - sourceId
11980 amit.gupta 3225 
     - dealerCoupon
11592 amit.gupta 3226 
    """
11980 amit.gupta 3227 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3228 
    return self.recv_validateCartPlus()
3229 
 
11980 amit.gupta 3230 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3231 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3232 
    args = validateCartPlus_args()
3233 
    args.cartId = cartId
3234 
    args.sourceId = sourceId
11980 amit.gupta 3235 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3236 
    args.write(self._oprot)
3237 
    self._oprot.writeMessageEnd()
3238 
    self._oprot.trans.flush()
3239 
 
3240 
  def recv_validateCartPlus(self, ):
3241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3242 
    if mtype == TMessageType.EXCEPTION:
3243 
      x = TApplicationException()
3244 
      x.read(self._iprot)
3245 
      self._iprot.readMessageEnd()
3246 
      raise x
3247 
    result = validateCartPlus_result()
3248 
    result.read(self._iprot)
3249 
    self._iprot.readMessageEnd()
3250 
    if result.success is not None:
3251 
      return result.success
3252 
    if result.scex is not None:
3253 
      raise result.scex
3254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3255 
 
11679 vikram.rag 3256 
  def isPrivateDealUser(self, userId):
3257 
    """
3258 
    Parameters:
3259 
     - userId
3260 
    """
3261 
    self.send_isPrivateDealUser(userId)
3262 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3263 
 
11679 vikram.rag 3264 
  def send_isPrivateDealUser(self, userId):
3265 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3266 
    args = isPrivateDealUser_args()
3267 
    args.userId = userId
3268 
    args.write(self._oprot)
3269 
    self._oprot.writeMessageEnd()
3270 
    self._oprot.trans.flush()
3271 
 
3272 
  def recv_isPrivateDealUser(self, ):
3273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3274 
    if mtype == TMessageType.EXCEPTION:
3275 
      x = TApplicationException()
3276 
      x.read(self._iprot)
3277 
      self._iprot.readMessageEnd()
3278 
      raise x
3279 
    result = isPrivateDealUser_result()
3280 
    result.read(self._iprot)
3281 
    self._iprot.readMessageEnd()
3282 
    if result.success is not None:
3283 
      return result.success
3284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3285 
 
11890 kshitij.so 3286 
  def addPrivateDealUser(self, userId):
3287 
    """
3288 
    Parameters:
3289 
     - userId
3290 
    """
3291 
    self.send_addPrivateDealUser(userId)
3292 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3293 
 
11890 kshitij.so 3294 
  def send_addPrivateDealUser(self, userId):
3295 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3296 
    args = addPrivateDealUser_args()
3297 
    args.userId = userId
3298 
    args.write(self._oprot)
3299 
    self._oprot.writeMessageEnd()
3300 
    self._oprot.trans.flush()
3301 
 
3302 
  def recv_addPrivateDealUser(self, ):
3303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3304 
    if mtype == TMessageType.EXCEPTION:
3305 
      x = TApplicationException()
3306 
      x.read(self._iprot)
3307 
      self._iprot.readMessageEnd()
3308 
      raise x
3309 
    result = addPrivateDealUser_result()
3310 
    result.read(self._iprot)
3311 
    self._iprot.readMessageEnd()
3312 
    if result.success is not None:
3313 
      return result.success
3314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3315 
 
3316 
  def changePrivateDealUserStatus(self, userId, isActive):
3317 
    """
3318 
    Parameters:
3319 
     - userId
3320 
     - isActive
3321 
    """
3322 
    self.send_changePrivateDealUserStatus(userId, isActive)
3323 
    return self.recv_changePrivateDealUserStatus()
3324 
 
3325 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3326 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3327 
    args = changePrivateDealUserStatus_args()
3328 
    args.userId = userId
3329 
    args.isActive = isActive
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_changePrivateDealUserStatus(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = changePrivateDealUserStatus_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    if result.success is not None:
3345 
      return result.success
3346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3347 
 
3348 
  def getPrivateDealUser(self, userId):
3349 
    """
3350 
    Parameters:
3351 
     - userId
3352 
    """
3353 
    self.send_getPrivateDealUser(userId)
3354 
    return self.recv_getPrivateDealUser()
3355 
 
3356 
  def send_getPrivateDealUser(self, userId):
3357 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3358 
    args = getPrivateDealUser_args()
3359 
    args.userId = userId
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_getPrivateDealUser(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = getPrivateDealUser_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3374 
    if result.success is not None:
3375 
      return result.success
3376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3377 
 
12696 amit.gupta 3378 
  def registerCounter(self, counter, userId):
3379 
    """
3380 
    Parameters:
3381 
     - counter
3382 
     - userId
3383 
    """
3384 
    self.send_registerCounter(counter, userId)
3385 
    return self.recv_registerCounter()
11890 kshitij.so 3386 
 
12696 amit.gupta 3387 
  def send_registerCounter(self, counter, userId):
3388 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3389 
    args = registerCounter_args()
3390 
    args.counter = counter
3391 
    args.userId = userId
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_registerCounter(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = registerCounter_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.success is not None:
3407 
      return result.success
3408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3409 
 
12722 amit.gupta 3410 
  def searchCounter(self, type1, searchString):
3411 
    """
3412 
    Parameters:
3413 
     - type1
3414 
     - searchString
3415 
    """
3416 
    self.send_searchCounter(type1, searchString)
3417 
    return self.recv_searchCounter()
12696 amit.gupta 3418 
 
12722 amit.gupta 3419 
  def send_searchCounter(self, type1, searchString):
3420 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3421 
    args = searchCounter_args()
3422 
    args.type1 = type1
3423 
    args.searchString = searchString
3424 
    args.write(self._oprot)
3425 
    self._oprot.writeMessageEnd()
3426 
    self._oprot.trans.flush()
3427 
 
3428 
  def recv_searchCounter(self, ):
3429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3430 
    if mtype == TMessageType.EXCEPTION:
3431 
      x = TApplicationException()
3432 
      x.read(self._iprot)
3433 
      self._iprot.readMessageEnd()
3434 
      raise x
3435 
    result = searchCounter_result()
3436 
    result.read(self._iprot)
3437 
    self._iprot.readMessageEnd()
3438 
    if result.success is not None:
3439 
      return result.success
3440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3441 
 
3442 
  def getAllUsersByCounter(self, counterId):
3443 
    """
3444 
    Parameters:
3445 
     - counterId
3446 
    """
3447 
    self.send_getAllUsersByCounter(counterId)
3448 
    return self.recv_getAllUsersByCounter()
3449 
 
3450 
  def send_getAllUsersByCounter(self, counterId):
3451 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3452 
    args = getAllUsersByCounter_args()
3453 
    args.counterId = counterId
3454 
    args.write(self._oprot)
3455 
    self._oprot.writeMessageEnd()
3456 
    self._oprot.trans.flush()
3457 
 
3458 
  def recv_getAllUsersByCounter(self, ):
3459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3460 
    if mtype == TMessageType.EXCEPTION:
3461 
      x = TApplicationException()
3462 
      x.read(self._iprot)
3463 
      self._iprot.readMessageEnd()
3464 
      raise x
3465 
    result = getAllUsersByCounter_result()
3466 
    result.read(self._iprot)
3467 
    self._iprot.readMessageEnd()
3468 
    if result.success is not None:
3469 
      return result.success
3470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3471 
 
15251 manish.sha 3472 
  def getActiveAccessTokenForUser(self, userId, source):
3473 
    """
3474 
    Parameters:
3475 
     - userId
3476 
     - source
3477 
    """
3478 
    self.send_getActiveAccessTokenForUser(userId, source)
3479 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3480 
 
15251 manish.sha 3481 
  def send_getActiveAccessTokenForUser(self, userId, source):
3482 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3483 
    args = getActiveAccessTokenForUser_args()
3484 
    args.userId = userId
3485 
    args.source = source
3486 
    args.write(self._oprot)
3487 
    self._oprot.writeMessageEnd()
3488 
    self._oprot.trans.flush()
3489 
 
3490 
  def recv_getActiveAccessTokenForUser(self, ):
3491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3492 
    if mtype == TMessageType.EXCEPTION:
3493 
      x = TApplicationException()
3494 
      x.read(self._iprot)
3495 
      self._iprot.readMessageEnd()
3496 
      raise x
3497 
    result = getActiveAccessTokenForUser_result()
3498 
    result.read(self._iprot)
3499 
    self._iprot.readMessageEnd()
3500 
    if result.success is not None:
3501 
      return result.success
3502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3503 
 
3504 
  def validateAccessToken(self, accessToken):
3505 
    """
3506 
    Parameters:
3507 
     - accessToken
3508 
    """
3509 
    self.send_validateAccessToken(accessToken)
3510 
    return self.recv_validateAccessToken()
3511 
 
3512 
  def send_validateAccessToken(self, accessToken):
3513 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3514 
    args = validateAccessToken_args()
3515 
    args.accessToken = accessToken
3516 
    args.write(self._oprot)
3517 
    self._oprot.writeMessageEnd()
3518 
    self._oprot.trans.flush()
3519 
 
3520 
  def recv_validateAccessToken(self, ):
3521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3522 
    if mtype == TMessageType.EXCEPTION:
3523 
      x = TApplicationException()
3524 
      x.read(self._iprot)
3525 
      self._iprot.readMessageEnd()
3526 
      raise x
3527 
    result = validateAccessToken_result()
3528 
    result.read(self._iprot)
3529 
    self._iprot.readMessageEnd()
3530 
    if result.success is not None:
3531 
      return result.success
3532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3533 
 
17782 amit.gupta 3534 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3535 
    """
3536 
    Parameters:
3537 
     - cartId
3538 
     - itemQty
3539 
     - couponCode
3540 
    """
3541 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3542 
    return self.recv_addItemsToCart()
15251 manish.sha 3543 
 
17782 amit.gupta 3544 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3545 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3546 
    args = addItemsToCart_args()
3547 
    args.cartId = cartId
3548 
    args.itemQty = itemQty
3549 
    args.couponCode = couponCode
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_addItemsToCart(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = addItemsToCart_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.success is not None:
3565 
      return result.success
3566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3567 
 
3568 
  def validateCartNew(self, cartId, pinCode, sourceId):
3569 
    """
3570 
    Parameters:
3571 
     - cartId
3572 
     - pinCode
3573 
     - sourceId
3574 
    """
3575 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3576 
    return self.recv_validateCartNew()
3577 
 
3578 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3579 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3580 
    args = validateCartNew_args()
3581 
    args.cartId = cartId
3582 
    args.pinCode = pinCode
3583 
    args.sourceId = sourceId
3584 
    args.write(self._oprot)
3585 
    self._oprot.writeMessageEnd()
3586 
    self._oprot.trans.flush()
3587 
 
3588 
  def recv_validateCartNew(self, ):
3589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3590 
    if mtype == TMessageType.EXCEPTION:
3591 
      x = TApplicationException()
3592 
      x.read(self._iprot)
3593 
      self._iprot.readMessageEnd()
3594 
      raise x
3595 
    result = validateCartNew_result()
3596 
    result.read(self._iprot)
3597 
    self._iprot.readMessageEnd()
3598 
    if result.success is not None:
3599 
      return result.success
3600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3601 
 
3602 
 
3376 rajveer 3603 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3604 
  def __init__(self, handler):
3376 rajveer 3605 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3606 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3607 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3608 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3609 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3610 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3611 
    self._processMap["createUser"] = Processor.process_createUser
3612 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3613 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3614 
    self._processMap["userExists"] = Processor.process_userExists
3615 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3616 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3617 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3618 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3619 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3620 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3621 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3622 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3623 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3624 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3625 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3626 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3627 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3628 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3629 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3630 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3631 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3632 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3633 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3634 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3635 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3636 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3637 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3638 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3639 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3640 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3641 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3642 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3643 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3644 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3645 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3646 
    self._processMap["getCart"] = Processor.process_getCart
3647 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3648 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3649 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3650 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3651 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3652 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3653 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3654 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3655 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3656 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3657 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3658 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3659 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3660 
    self._processMap["checkOut"] = Processor.process_checkOut
3661 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3662 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3663 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3664 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3665 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3666 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3667 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3668 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3669 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3670 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3671 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3672 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3673 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3674 
    self._processMap["insureItem"] = Processor.process_insureItem
3675 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3676 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3677 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3678 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3679 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3680 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3681 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3682 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3683 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3684 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3685 
    self._processMap["searchCounter"] = Processor.process_searchCounter
3686 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3687 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3688 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3689 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3690 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
94 ashish 3691 
 
3692 
  def process(self, iprot, oprot):
3693 
    (name, type, seqid) = iprot.readMessageBegin()
3694 
    if name not in self._processMap:
3695 
      iprot.skip(TType.STRUCT)
3696 
      iprot.readMessageEnd()
3697 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3698 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3699 
      x.write(oprot)
3700 
      oprot.writeMessageEnd()
3701 
      oprot.trans.flush()
3702 
      return
3703 
    else:
3704 
      self._processMap[name](self, seqid, iprot, oprot)
3705 
    return True
3706 
 
559 chandransh 3707 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3708 
    args = createAnonymousUser_args()
94 ashish 3709 
    args.read(iprot)
3710 
    iprot.readMessageEnd()
559 chandransh 3711 
    result = createAnonymousUser_result()
94 ashish 3712 
    try:
559 chandransh 3713 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3714 
    except UserContextException, ucex:
3715 
      result.ucex = ucex
3716 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3717 
    result.write(oprot)
3718 
    oprot.writeMessageEnd()
3719 
    oprot.trans.flush()
3720 
 
559 chandransh 3721 
  def process_getUserById(self, seqid, iprot, oprot):
3722 
    args = getUserById_args()
94 ashish 3723 
    args.read(iprot)
3724 
    iprot.readMessageEnd()
559 chandransh 3725 
    result = getUserById_result()
94 ashish 3726 
    try:
559 chandransh 3727 
      result.success = self._handler.getUserById(args.userId)
3728 
    except UserContextException, ucex:
3729 
      result.ucex = ucex
3730 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3731 
    result.write(oprot)
3732 
    oprot.writeMessageEnd()
3733 
    oprot.trans.flush()
3734 
 
5326 rajveer 3735 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3736 
    args = getUserByCartId_args()
3737 
    args.read(iprot)
3738 
    iprot.readMessageEnd()
3739 
    result = getUserByCartId_result()
3740 
    try:
3741 
      result.success = self._handler.getUserByCartId(args.cartId)
3742 
    except UserContextException, ucex:
3743 
      result.ucex = ucex
3744 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3745 
    result.write(oprot)
3746 
    oprot.writeMessageEnd()
3747 
    oprot.trans.flush()
3748 
 
1491 vikas 3749 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3750 
    args = getUserByEmail_args()
3751 
    args.read(iprot)
3752 
    iprot.readMessageEnd()
3753 
    result = getUserByEmail_result()
3754 
    try:
3755 
      result.success = self._handler.getUserByEmail(args.email)
3756 
    except UserContextException, ucex:
3757 
      result.ucex = ucex
3758 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3759 
    result.write(oprot)
3760 
    oprot.writeMessageEnd()
3761 
    oprot.trans.flush()
3762 
 
3032 mandeep.dh 3763 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3764 
    args = getUserByMobileNumber_args()
3765 
    args.read(iprot)
3766 
    iprot.readMessageEnd()
3767 
    result = getUserByMobileNumber_result()
3768 
    try:
3769 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3770 
    except UserContextException, ucex:
3771 
      result.ucex = ucex
3772 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3773 
    result.write(oprot)
3774 
    oprot.writeMessageEnd()
3775 
    oprot.trans.flush()
3776 
 
559 chandransh 3777 
  def process_createUser(self, seqid, iprot, oprot):
3778 
    args = createUser_args()
94 ashish 3779 
    args.read(iprot)
3780 
    iprot.readMessageEnd()
559 chandransh 3781 
    result = createUser_result()
94 ashish 3782 
    try:
559 chandransh 3783 
      result.success = self._handler.createUser(args.user)
3784 
    except UserContextException, ucex:
3785 
      result.ucex = ucex
3786 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3787 
    result.write(oprot)
3788 
    oprot.writeMessageEnd()
3789 
    oprot.trans.flush()
3790 
 
559 chandransh 3791 
  def process_updateUser(self, seqid, iprot, oprot):
3792 
    args = updateUser_args()
94 ashish 3793 
    args.read(iprot)
3794 
    iprot.readMessageEnd()
559 chandransh 3795 
    result = updateUser_result()
94 ashish 3796 
    try:
559 chandransh 3797 
      result.success = self._handler.updateUser(args.user)
3798 
    except UserContextException, ucex:
3799 
      result.ucex = ucex
3800 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
3804 
 
122 ashish 3805 
  def process_authenticateUser(self, seqid, iprot, oprot):
3806 
    args = authenticateUser_args()
3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
3809 
    result = authenticateUser_result()
3810 
    try:
559 chandransh 3811 
      result.success = self._handler.authenticateUser(args.email, args.password)
3812 
    except AuthenticationException, auex:
3813 
      result.auex = auex
122 ashish 3814 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
3818 
 
94 ashish 3819 
  def process_userExists(self, seqid, iprot, oprot):
3820 
    args = userExists_args()
3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
3823 
    result = userExists_result()
3824 
    try:
3825 
      result.success = self._handler.userExists(args.email)
3826 
    except UserContextException, ucx:
3827 
      result.ucx = ucx
3828 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3829 
    result.write(oprot)
3830 
    oprot.writeMessageEnd()
3831 
    oprot.trans.flush()
3832 
 
3833 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3834 
    args = addAddressForUser_args()
3835 
    args.read(iprot)
3836 
    iprot.readMessageEnd()
3837 
    result = addAddressForUser_result()
3838 
    try:
567 rajveer 3839 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3840 
    except UserContextException, ucx:
3841 
      result.ucx = ucx
3842 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3843 
    result.write(oprot)
3844 
    oprot.writeMessageEnd()
3845 
    oprot.trans.flush()
3846 
 
3847 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3848 
    args = removeAddressForUser_args()
3849 
    args.read(iprot)
3850 
    iprot.readMessageEnd()
3851 
    result = removeAddressForUser_result()
3852 
    try:
3853 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3854 
    except UserContextException, ucx:
3855 
      result.ucx = ucx
3856 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3857 
    result.write(oprot)
3858 
    oprot.writeMessageEnd()
3859 
    oprot.trans.flush()
3860 
 
3861 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3862 
    args = setUserAsLoggedIn_args()
3863 
    args.read(iprot)
3864 
    iprot.readMessageEnd()
3865 
    result = setUserAsLoggedIn_result()
3866 
    try:
3867 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3868 
    except UserContextException, ucx:
3869 
      result.ucx = ucx
3870 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3871 
    result.write(oprot)
3872 
    oprot.writeMessageEnd()
3873 
    oprot.trans.flush()
3874 
 
3875 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3876 
    args = setUserAsLoggedOut_args()
3877 
    args.read(iprot)
3878 
    iprot.readMessageEnd()
3879 
    result = setUserAsLoggedOut_result()
3880 
    try:
3881 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3882 
    except UserContextException, ucx:
3883 
      result.ucx = ucx
3884 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3885 
    result.write(oprot)
3886 
    oprot.writeMessageEnd()
3887 
    oprot.trans.flush()
3888 
 
504 rajveer 3889 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3890 
    args = setDefaultAddress_args()
3891 
    args.read(iprot)
3892 
    iprot.readMessageEnd()
3893 
    result = setDefaultAddress_result()
3894 
    try:
3895 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3896 
    except UserContextException, ucx:
3897 
      result.ucx = ucx
3898 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3899 
    result.write(oprot)
3900 
    oprot.writeMessageEnd()
3901 
    oprot.trans.flush()
3902 
 
94 ashish 3903 
  def process_updatePassword(self, seqid, iprot, oprot):
3904 
    args = updatePassword_args()
3905 
    args.read(iprot)
3906 
    iprot.readMessageEnd()
3907 
    result = updatePassword_result()
3908 
    try:
594 rajveer 3909 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3910 
    except UserContextException, ucx:
3911 
      result.ucx = ucx
3912 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3913 
    result.write(oprot)
3914 
    oprot.writeMessageEnd()
3915 
    oprot.trans.flush()
3916 
 
581 rajveer 3917 
  def process_forgotPassword(self, seqid, iprot, oprot):
3918 
    args = forgotPassword_args()
3919 
    args.read(iprot)
3920 
    iprot.readMessageEnd()
3921 
    result = forgotPassword_result()
3922 
    try:
884 rajveer 3923 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3924 
    except UserContextException, ucx:
3925 
      result.ucx = ucx
3926 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3927 
    result.write(oprot)
3928 
    oprot.writeMessageEnd()
3929 
    oprot.trans.flush()
3930 
 
594 rajveer 3931 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3932 
    args = getAllAddressesForUser_args()
3933 
    args.read(iprot)
3934 
    iprot.readMessageEnd()
3935 
    result = getAllAddressesForUser_result()
3936 
    try:
3937 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3938 
    except UserContextException, ucx:
3939 
      result.ucx = ucx
3940 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3941 
    result.write(oprot)
3942 
    oprot.writeMessageEnd()
3943 
    oprot.trans.flush()
3944 
 
1894 vikas 3945 
  def process_getAddressById(self, seqid, iprot, oprot):
3946 
    args = getAddressById_args()
3947 
    args.read(iprot)
3948 
    iprot.readMessageEnd()
3949 
    result = getAddressById_result()
3950 
    try:
3951 
      result.success = self._handler.getAddressById(args.addressId)
3952 
    except UserContextException, ucx:
3953 
      result.ucx = ucx
3954 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3955 
    result.write(oprot)
3956 
    oprot.writeMessageEnd()
3957 
    oprot.trans.flush()
3958 
 
594 rajveer 3959 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3960 
    args = getDefaultAddressId_args()
3961 
    args.read(iprot)
3962 
    iprot.readMessageEnd()
3963 
    result = getDefaultAddressId_result()
3964 
    try:
3965 
      result.success = self._handler.getDefaultAddressId(args.userId)
3966 
    except UserContextException, ucx:
3967 
      result.ucx = ucx
3968 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3969 
    result.write(oprot)
3970 
    oprot.writeMessageEnd()
3971 
    oprot.trans.flush()
3972 
 
785 rajveer 3973 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3974 
    args = getDefaultPincode_args()
3975 
    args.read(iprot)
3976 
    iprot.readMessageEnd()
3977 
    result = getDefaultPincode_result()
3978 
    try:
3979 
      result.success = self._handler.getDefaultPincode(args.userId)
3980 
    except UserContextException, ucx:
3981 
      result.ucx = ucx
3982 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3983 
    result.write(oprot)
3984 
    oprot.writeMessageEnd()
3985 
    oprot.trans.flush()
3986 
 
1274 varun.gupt 3987 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3988 
    args = saveUserCommunication_args()
3989 
    args.read(iprot)
3990 
    iprot.readMessageEnd()
3991 
    result = saveUserCommunication_result()
3992 
    try:
3993 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3994 
    except UserCommunicationException, ucx:
3995 
      result.ucx = ucx
3996 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3997 
    result.write(oprot)
3998 
    oprot.writeMessageEnd()
3999 
    oprot.trans.flush()
4000 
 
1590 varun.gupt 4001 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4002 
    args = getUserCommunicationById_args()
4003 
    args.read(iprot)
4004 
    iprot.readMessageEnd()
4005 
    result = getUserCommunicationById_result()
4006 
    try:
4007 
      result.success = self._handler.getUserCommunicationById(args.id)
4008 
    except UserCommunicationException, ucx:
4009 
      result.ucx = ucx
4010 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4011 
    result.write(oprot)
4012 
    oprot.writeMessageEnd()
4013 
    oprot.trans.flush()
4014 
 
4015 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4016 
    args = getUserCommunicationByUser_args()
4017 
    args.read(iprot)
4018 
    iprot.readMessageEnd()
4019 
    result = getUserCommunicationByUser_result()
4020 
    try:
4021 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4022 
    except UserCommunicationException, ucx:
4023 
      result.ucx = ucx
4024 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4025 
    result.write(oprot)
4026 
    oprot.writeMessageEnd()
4027 
    oprot.trans.flush()
4028 
 
4029 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4030 
    args = getAllUserCommunications_args()
4031 
    args.read(iprot)
4032 
    iprot.readMessageEnd()
4033 
    result = getAllUserCommunications_result()
4034 
    try:
4035 
      result.success = self._handler.getAllUserCommunications()
4036 
    except UserCommunicationException, ucx:
4037 
      result.ucx = ucx
4038 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4039 
    result.write(oprot)
4040 
    oprot.writeMessageEnd()
4041 
    oprot.trans.flush()
4042 
 
5407 amar.kumar 4043 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4044 
    args = removeUserCommunication_args()
4045 
    args.read(iprot)
4046 
    iprot.readMessageEnd()
4047 
    result = removeUserCommunication_result()
4048 
    try:
4049 
      self._handler.removeUserCommunication(args.id)
4050 
    except UserCommunicationException, ucx:
4051 
      result.ucx = ucx
4052 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4053 
    result.write(oprot)
4054 
    oprot.writeMessageEnd()
4055 
    oprot.trans.flush()
4056 
 
1845 vikas 4057 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4058 
    args = createMasterAffiliate_args()
4059 
    args.read(iprot)
4060 
    iprot.readMessageEnd()
4061 
    result = createMasterAffiliate_result()
4062 
    try:
1859 vikas 4063 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4064 
    except UserAffiliateException, utx:
1845 vikas 4065 
      result.utx = utx
4066 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4067 
    result.write(oprot)
4068 
    oprot.writeMessageEnd()
4069 
    oprot.trans.flush()
4070 
 
1899 vikas 4071 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4072 
    args = getAllMasterAffiliates_args()
4073 
    args.read(iprot)
4074 
    iprot.readMessageEnd()
4075 
    result = getAllMasterAffiliates_result()
4076 
    try:
4077 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4078 
    except UserAffiliateException, utx:
1899 vikas 4079 
      result.utx = utx
4080 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4081 
    result.write(oprot)
4082 
    oprot.writeMessageEnd()
4083 
    oprot.trans.flush()
4084 
 
1845 vikas 4085 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4086 
    args = getMasterAffiliateById_args()
4087 
    args.read(iprot)
4088 
    iprot.readMessageEnd()
4089 
    result = getMasterAffiliateById_result()
4090 
    try:
4091 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4092 
    except UserAffiliateException, utx:
1845 vikas 4093 
      result.utx = utx
4094 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4095 
    result.write(oprot)
4096 
    oprot.writeMessageEnd()
4097 
    oprot.trans.flush()
4098 
 
4099 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4100 
    args = getMasterAffiliateByName_args()
4101 
    args.read(iprot)
4102 
    iprot.readMessageEnd()
4103 
    result = getMasterAffiliateByName_result()
4104 
    try:
4105 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4106 
    except UserAffiliateException, utx:
1845 vikas 4107 
      result.utx = utx
4108 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4109 
    result.write(oprot)
4110 
    oprot.writeMessageEnd()
4111 
    oprot.trans.flush()
4112 
 
4113 
  def process_createAffiliate(self, seqid, iprot, oprot):
4114 
    args = createAffiliate_args()
4115 
    args.read(iprot)
4116 
    iprot.readMessageEnd()
4117 
    result = createAffiliate_result()
4118 
    try:
1859 vikas 4119 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4120 
    except UserAffiliateException, utx:
1845 vikas 4121 
      result.utx = utx
4122 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4127 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4128 
    args = getAffiliateById_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = getAffiliateById_result()
4132 
    try:
4133 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4134 
    except UserAffiliateException, utx:
1845 vikas 4135 
      result.utx = utx
4136 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4137 
    result.write(oprot)
4138 
    oprot.writeMessageEnd()
4139 
    oprot.trans.flush()
4140 
 
4141 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4142 
    args = getAffiliateByName_args()
4143 
    args.read(iprot)
4144 
    iprot.readMessageEnd()
4145 
    result = getAffiliateByName_result()
4146 
    try:
4147 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4148 
    except UserAffiliateException, utx:
1845 vikas 4149 
      result.utx = utx
4150 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
4155 
  def process_getTrackerById(self, seqid, iprot, oprot):
4156 
    args = getTrackerById_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = getTrackerById_result()
4160 
    try:
1996 vikas 4161 
      result.success = self._handler.getTrackerById(args.id)
4162 
    except UserAffiliateException, utx:
1845 vikas 4163 
      result.utx = utx
4164 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
1996 vikas 4169 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4170 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
1996 vikas 4173 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4174 
    try:
1996 vikas 4175 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4176 
    except UserAffiliateException, utx:
1845 vikas 4177 
      result.utx = utx
1996 vikas 4178 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
4183 
  def process_addTrackLog(self, seqid, iprot, oprot):
4184 
    args = addTrackLog_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = addTrackLog_result()
4188 
    try:
1996 vikas 4189 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4190 
    except UserAffiliateException, utx:
1845 vikas 4191 
      result.utx = utx
4192 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
4197 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4198 
    args = getTrackLogById_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = getTrackLogById_result()
4202 
    try:
4203 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4204 
    except UserAffiliateException, utx:
1845 vikas 4205 
      result.utx = utx
4206 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
1996 vikas 4211 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4212 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
1996 vikas 4215 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4216 
    try:
3293 vikas 4217 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4218 
    except UserAffiliateException, utx:
1845 vikas 4219 
      result.utx = utx
1996 vikas 4220 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4224 
 
4225 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4226 
    args = getTrackLogsByUser_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = getTrackLogsByUser_result()
4230 
    try:
4231 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4232 
    except UserAffiliateException, utx:
1845 vikas 4233 
      result.utx = utx
4234 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4240 
    args = getTrackLogs_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getTrackLogs_result()
4244 
    try:
1996 vikas 4245 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4246 
    except UserAffiliateException, utx:
1845 vikas 4247 
      result.utx = utx
4248 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
559 chandransh 4253 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4254 
    args = getCurrentCart_args()
94 ashish 4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
559 chandransh 4257 
    result = getCurrentCart_result()
94 ashish 4258 
    try:
559 chandransh 4259 
      result.success = self._handler.getCurrentCart(args.userId)
4260 
    except ShoppingCartException, scx:
4261 
      result.scx = scx
4262 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
4266 
 
559 chandransh 4267 
  def process_getCart(self, seqid, iprot, oprot):
4268 
    args = getCart_args()
94 ashish 4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
559 chandransh 4271 
    result = getCart_result()
94 ashish 4272 
    try:
559 chandransh 4273 
      result.success = self._handler.getCart(args.cartId)
4274 
    except ShoppingCartException, scx:
4275 
      result.scx = scx
4276 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
559 chandransh 4281 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4282 
    args = getCartsByTime_args()
94 ashish 4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
559 chandransh 4285 
    result = getCartsByTime_result()
94 ashish 4286 
    try:
559 chandransh 4287 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4288 
    except ShoppingCartException, scx:
4289 
      result.scx = scx
4290 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
559 chandransh 4295 
  def process_addItemToCart(self, seqid, iprot, oprot):
4296 
    args = addItemToCart_args()
130 ashish 4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
559 chandransh 4299 
    result = addItemToCart_result()
130 ashish 4300 
    try:
3557 rajveer 4301 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4302 
    except ShoppingCartException, scx:
4303 
      result.scx = scx
4304 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
4308 
 
559 chandransh 4309 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4310 
    args = deleteItemFromCart_args()
4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
4313 
    result = deleteItemFromCart_result()
4314 
    try:
4315 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4316 
    except ShoppingCartException, scx:
4317 
      result.scx = scx
4318 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4319 
    result.write(oprot)
4320 
    oprot.writeMessageEnd()
4321 
    oprot.trans.flush()
130 ashish 4322 
 
559 chandransh 4323 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4324 
    args = addAddressToCart_args()
4325 
    args.read(iprot)
4326 
    iprot.readMessageEnd()
4327 
    result = addAddressToCart_result()
575 chandransh 4328 
    try:
4329 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4330 
    except ShoppingCartException, scx:
4331 
      result.scx = scx
559 chandransh 4332 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4333 
    result.write(oprot)
4334 
    oprot.writeMessageEnd()
4335 
    oprot.trans.flush()
4336 
 
5553 rajveer 4337 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4338 
    args = addStoreToCart_args()
4339 
    args.read(iprot)
4340 
    iprot.readMessageEnd()
4341 
    result = addStoreToCart_result()
4342 
    try:
4343 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4344 
    except ShoppingCartException, scx:
4345 
      result.scx = scx
4346 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4347 
    result.write(oprot)
4348 
    oprot.writeMessageEnd()
4349 
    oprot.trans.flush()
4350 
 
1976 varun.gupt 4351 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4352 
    args = applyCouponToCart_args()
4353 
    args.read(iprot)
4354 
    iprot.readMessageEnd()
4355 
    result = applyCouponToCart_result()
4356 
    try:
6922 anupam.sin 4357 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4358 
    except ShoppingCartException, scx:
4359 
      result.scx = scx
4360 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4361 
    result.write(oprot)
4362 
    oprot.writeMessageEnd()
4363 
    oprot.trans.flush()
4364 
 
4365 
  def process_removeCoupon(self, seqid, iprot, oprot):
4366 
    args = removeCoupon_args()
4367 
    args.read(iprot)
4368 
    iprot.readMessageEnd()
4369 
    result = removeCoupon_result()
4370 
    try:
4371 
      self._handler.removeCoupon(args.cartId)
4372 
    except ShoppingCartException, scx:
4373 
      result.scx = scx
4374 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4375 
    result.write(oprot)
4376 
    oprot.writeMessageEnd()
4377 
    oprot.trans.flush()
4378 
 
3554 varun.gupt 4379 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4380 
    args = deleteDiscountsFromCart_args()
4381 
    args.read(iprot)
4382 
    iprot.readMessageEnd()
4383 
    result = deleteDiscountsFromCart_result()
4384 
    try:
4385 
      self._handler.deleteDiscountsFromCart(args.cartId)
4386 
    except ShoppingCartException, scx:
4387 
      result.scx = scx
4388 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4389 
    result.write(oprot)
4390 
    oprot.writeMessageEnd()
4391 
    oprot.trans.flush()
4392 
 
4393 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4394 
    args = saveDiscounts_args()
4395 
    args.read(iprot)
4396 
    iprot.readMessageEnd()
4397 
    result = saveDiscounts_result()
4398 
    try:
4399 
      self._handler.saveDiscounts(args.discounts)
4400 
    except ShoppingCartException, scx:
4401 
      result.scx = scx
4402 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
690 chandransh 4407 
  def process_createOrders(self, seqid, iprot, oprot):
4408 
    args = createOrders_args()
559 chandransh 4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
690 chandransh 4411 
    result = createOrders_result()
559 chandransh 4412 
    try:
11526 amit.gupta 4413 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4414 
    except ShoppingCartException, scx:
4415 
      result.scx = scx
690 chandransh 4416 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
4420 
 
4421 
  def process_validateCart(self, seqid, iprot, oprot):
4422 
    args = validateCart_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    result = validateCart_result()
575 chandransh 4426 
    try:
3557 rajveer 4427 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4428 
    except ShoppingCartException, scex:
4429 
      result.scex = scex
559 chandransh 4430 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
11980 amit.gupta 4435 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4436 
    args = validateCartWithDealerCoupon_args()
4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
4439 
    result = validateCartWithDealerCoupon_result()
4440 
    try:
4441 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4442 
    except ShoppingCartException, scex:
4443 
      result.scex = scex
4444 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
4448 
 
690 chandransh 4449 
  def process_mergeCart(self, seqid, iprot, oprot):
4450 
    args = mergeCart_args()
575 chandransh 4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
690 chandransh 4453 
    result = mergeCart_result()
4454 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4455 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4456 
    result.write(oprot)
4457 
    oprot.writeMessageEnd()
4458 
    oprot.trans.flush()
4459 
 
4460 
  def process_checkOut(self, seqid, iprot, oprot):
4461 
    args = checkOut_args()
4462 
    args.read(iprot)
4463 
    iprot.readMessageEnd()
4464 
    result = checkOut_result()
575 chandransh 4465 
    try:
690 chandransh 4466 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4467 
    except ShoppingCartException, scex:
4468 
      result.scex = scex
690 chandransh 4469 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4470 
    result.write(oprot)
4471 
    oprot.writeMessageEnd()
4472 
    oprot.trans.flush()
4473 
 
690 chandransh 4474 
  def process_resetCart(self, seqid, iprot, oprot):
4475 
    args = resetCart_args()
559 chandransh 4476 
    args.read(iprot)
4477 
    iprot.readMessageEnd()
690 chandransh 4478 
    result = resetCart_result()
4479 
    try:
4480 
      result.success = self._handler.resetCart(args.cartId, args.items)
4481 
    except ShoppingCartException, scex:
4482 
      result.scex = scex
4483 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
4487 
 
2981 rajveer 4488 
  def process_getUserCount(self, seqid, iprot, oprot):
4489 
    args = getUserCount_args()
559 chandransh 4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
2981 rajveer 4492 
    result = getUserCount_result()
4493 
    result.success = self._handler.getUserCount(args.userType)
4494 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
2981 rajveer 4499 
  def process_getAllUsers(self, seqid, iprot, oprot):
4500 
    args = getAllUsers_args()
559 chandransh 4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
2981 rajveer 4503 
    result = getAllUsers_result()
4504 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4505 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
4509 
 
2981 rajveer 4510 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4511 
    args = getMyResearchItems_args()
559 chandransh 4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
2981 rajveer 4514 
    result = getMyResearchItems_result()
559 chandransh 4515 
    try:
2981 rajveer 4516 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4517 
    except WidgetException, scx:
4518 
      result.scx = scx
2981 rajveer 4519 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4520 
    result.write(oprot)
4521 
    oprot.writeMessageEnd()
4522 
    oprot.trans.flush()
4523 
 
2981 rajveer 4524 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4525 
    args = updateMyResearch_args()
772 rajveer 4526 
    args.read(iprot)
4527 
    iprot.readMessageEnd()
2981 rajveer 4528 
    result = updateMyResearch_result()
4529 
    try:
4530 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4531 
    except WidgetException, scx:
4532 
      result.scx = scx
4533 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4534 
    result.write(oprot)
4535 
    oprot.writeMessageEnd()
4536 
    oprot.trans.flush()
559 chandransh 4537 
 
2981 rajveer 4538 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4539 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
2981 rajveer 4542 
    result = deleteItemFromMyResearch_result()
4543 
    try:
4544 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4545 
    except WidgetException, scx:
4546 
      result.scx = scx
4547 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4548 
    result.write(oprot)
4549 
    oprot.writeMessageEnd()
4550 
    oprot.trans.flush()
772 rajveer 4551 
 
2981 rajveer 4552 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4553 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4554 
    args.read(iprot)
4555 
    iprot.readMessageEnd()
2981 rajveer 4556 
    result = getBrowseHistoryItems_result()
4557 
    try:
4558 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4559 
    except WidgetException, scx:
4560 
      result.scx = scx
4561 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4562 
    result.write(oprot)
4563 
    oprot.writeMessageEnd()
4564 
    oprot.trans.flush()
1596 ankur.sing 4565 
 
2981 rajveer 4566 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4567 
    args = updateBrowseHistory_args()
2642 varun.gupt 4568 
    args.read(iprot)
4569 
    iprot.readMessageEnd()
2981 rajveer 4570 
    result = updateBrowseHistory_result()
4571 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4572 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4573 
    result.write(oprot)
4574 
    oprot.writeMessageEnd()
4575 
    oprot.trans.flush()
1673 ankur.sing 4576 
 
3385 varun.gupt 4577 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4578 
    args = getCartsWithCouponCount_args()
4579 
    args.read(iprot)
4580 
    iprot.readMessageEnd()
4581 
    result = getCartsWithCouponCount_result()
4582 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4583 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4584 
    result.write(oprot)
4585 
    oprot.writeMessageEnd()
4586 
    oprot.trans.flush()
2642 varun.gupt 4587 
 
3499 mandeep.dh 4588 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4589 
    args = increaseTrustLevel_args()
4590 
    args.read(iprot)
4591 
    iprot.readMessageEnd()
4592 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4593 
    return
3385 varun.gupt 4594 
 
5407 amar.kumar 4595 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4596 
    args = getTrustLevel_args()
4597 
    args.read(iprot)
4598 
    iprot.readMessageEnd()
4599 
    result = getTrustLevel_result()
4600 
    result.success = self._handler.getTrustLevel(args.userId)
4601 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4602 
    result.write(oprot)
4603 
    oprot.writeMessageEnd()
4604 
    oprot.trans.flush()
4605 
 
4668 varun.gupt 4606 
  def process_showCODOption(self, seqid, iprot, oprot):
4607 
    args = showCODOption_args()
4608 
    args.read(iprot)
4609 
    iprot.readMessageEnd()
4610 
    result = showCODOption_result()
4611 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4612 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4613 
    result.write(oprot)
4614 
    oprot.writeMessageEnd()
4615 
    oprot.trans.flush()
3499 mandeep.dh 4616 
 
5623 anupam.sin 4617 
  def process_getUserEmails(self, seqid, iprot, oprot):
4618 
    args = getUserEmails_args()
4619 
    args.read(iprot)
4620 
    iprot.readMessageEnd()
4621 
    result = getUserEmails_result()
4622 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4623 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4624 
    result.write(oprot)
4625 
    oprot.writeMessageEnd()
4626 
    oprot.trans.flush()
4668 varun.gupt 4627 
 
6903 anupam.sin 4628 
  def process_insureItem(self, seqid, iprot, oprot):
4629 
    args = insureItem_args()
4630 
    args.read(iprot)
4631 
    iprot.readMessageEnd()
4632 
    result = insureItem_result()
9299 kshitij.so 4633 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4634 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4638 
 
4639 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4640 
    args = cancelInsurance_args()
4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
4643 
    result = cancelInsurance_result()
4644 
    result.success = self._handler.cancelInsurance(args.cartId)
4645 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4650 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4651 
    args = storeInsuranceSpecificDetails_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = storeInsuranceSpecificDetails_result()
4655 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4656 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4657 
    result.write(oprot)
4658 
    oprot.writeMessageEnd()
4659 
    oprot.trans.flush()
4660 
 
4661 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4662 
    args = isInsuranceDetailPresent_args()
4663 
    args.read(iprot)
4664 
    iprot.readMessageEnd()
4665 
    result = isInsuranceDetailPresent_result()
4666 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4667 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4668 
    result.write(oprot)
4669 
    oprot.writeMessageEnd()
4670 
    oprot.trans.flush()
4671 
 
9791 rajveer 4672 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4673 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4674 
    args.read(iprot)
4675 
    iprot.readMessageEnd()
9791 rajveer 4676 
    result = getProductsAddedToCart_result()
4677 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4678 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4679 
    result.write(oprot)
4680 
    oprot.writeMessageEnd()
4681 
    oprot.trans.flush()
5623 anupam.sin 4682 
 
11592 amit.gupta 4683 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4684 
    args = validateCartPlus_args()
4685 
    args.read(iprot)
4686 
    iprot.readMessageEnd()
4687 
    result = validateCartPlus_result()
4688 
    try:
11980 amit.gupta 4689 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4690 
    except ShoppingCartException, scex:
4691 
      result.scex = scex
4692 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4693 
    result.write(oprot)
4694 
    oprot.writeMessageEnd()
4695 
    oprot.trans.flush()
6821 amar.kumar 4696 
 
11679 vikram.rag 4697 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4698 
    args = isPrivateDealUser_args()
4699 
    args.read(iprot)
4700 
    iprot.readMessageEnd()
4701 
    result = isPrivateDealUser_result()
4702 
    result.success = self._handler.isPrivateDealUser(args.userId)
4703 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4704 
    result.write(oprot)
4705 
    oprot.writeMessageEnd()
4706 
    oprot.trans.flush()
11592 amit.gupta 4707 
 
11890 kshitij.so 4708 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4709 
    args = addPrivateDealUser_args()
4710 
    args.read(iprot)
4711 
    iprot.readMessageEnd()
4712 
    result = addPrivateDealUser_result()
4713 
    result.success = self._handler.addPrivateDealUser(args.userId)
4714 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4715 
    result.write(oprot)
4716 
    oprot.writeMessageEnd()
4717 
    oprot.trans.flush()
11679 vikram.rag 4718 
 
11890 kshitij.so 4719 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4720 
    args = changePrivateDealUserStatus_args()
4721 
    args.read(iprot)
4722 
    iprot.readMessageEnd()
4723 
    result = changePrivateDealUserStatus_result()
4724 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4725 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4726 
    result.write(oprot)
4727 
    oprot.writeMessageEnd()
4728 
    oprot.trans.flush()
4729 
 
4730 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4731 
    args = getPrivateDealUser_args()
4732 
    args.read(iprot)
4733 
    iprot.readMessageEnd()
4734 
    result = getPrivateDealUser_result()
4735 
    result.success = self._handler.getPrivateDealUser(args.userId)
4736 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4737 
    result.write(oprot)
4738 
    oprot.writeMessageEnd()
4739 
    oprot.trans.flush()
4740 
 
12696 amit.gupta 4741 
  def process_registerCounter(self, seqid, iprot, oprot):
4742 
    args = registerCounter_args()
4743 
    args.read(iprot)
4744 
    iprot.readMessageEnd()
4745 
    result = registerCounter_result()
4746 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4747 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4748 
    result.write(oprot)
4749 
    oprot.writeMessageEnd()
4750 
    oprot.trans.flush()
11890 kshitij.so 4751 
 
12722 amit.gupta 4752 
  def process_searchCounter(self, seqid, iprot, oprot):
4753 
    args = searchCounter_args()
4754 
    args.read(iprot)
4755 
    iprot.readMessageEnd()
4756 
    result = searchCounter_result()
4757 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4758 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4759 
    result.write(oprot)
4760 
    oprot.writeMessageEnd()
4761 
    oprot.trans.flush()
12696 amit.gupta 4762 
 
12722 amit.gupta 4763 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
4764 
    args = getAllUsersByCounter_args()
4765 
    args.read(iprot)
4766 
    iprot.readMessageEnd()
4767 
    result = getAllUsersByCounter_result()
4768 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
4769 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
4770 
    result.write(oprot)
4771 
    oprot.writeMessageEnd()
4772 
    oprot.trans.flush()
4773 
 
15251 manish.sha 4774 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
4775 
    args = getActiveAccessTokenForUser_args()
4776 
    args.read(iprot)
4777 
    iprot.readMessageEnd()
4778 
    result = getActiveAccessTokenForUser_result()
4779 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
4780 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
4781 
    result.write(oprot)
4782 
    oprot.writeMessageEnd()
4783 
    oprot.trans.flush()
12722 amit.gupta 4784 
 
15251 manish.sha 4785 
  def process_validateAccessToken(self, seqid, iprot, oprot):
4786 
    args = validateAccessToken_args()
4787 
    args.read(iprot)
4788 
    iprot.readMessageEnd()
4789 
    result = validateAccessToken_result()
4790 
    result.success = self._handler.validateAccessToken(args.accessToken)
4791 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
4792 
    result.write(oprot)
4793 
    oprot.writeMessageEnd()
4794 
    oprot.trans.flush()
4795 
 
17782 amit.gupta 4796 
  def process_addItemsToCart(self, seqid, iprot, oprot):
4797 
    args = addItemsToCart_args()
4798 
    args.read(iprot)
4799 
    iprot.readMessageEnd()
4800 
    result = addItemsToCart_result()
4801 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
4802 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
4803 
    result.write(oprot)
4804 
    oprot.writeMessageEnd()
4805 
    oprot.trans.flush()
15251 manish.sha 4806 
 
17782 amit.gupta 4807 
  def process_validateCartNew(self, seqid, iprot, oprot):
4808 
    args = validateCartNew_args()
4809 
    args.read(iprot)
4810 
    iprot.readMessageEnd()
4811 
    result = validateCartNew_result()
4812 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
4813 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
4814 
    result.write(oprot)
4815 
    oprot.writeMessageEnd()
4816 
    oprot.trans.flush()
4817 
 
4818 
 
94 ashish 4819 
# HELPER FUNCTIONS AND STRUCTURES
4820 
 
559 chandransh 4821 
class createAnonymousUser_args:
94 ashish 4822 
  """
4823 
  Attributes:
559 chandransh 4824 
   - jsessionId
94 ashish 4825 
  """
4826 
 
4827 
  thrift_spec = (
4828 
    None, # 0
559 chandransh 4829 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 4830 
  )
4831 
 
559 chandransh 4832 
  def __init__(self, jsessionId=None,):
4833 
    self.jsessionId = jsessionId
94 ashish 4834 
 
4835 
  def read(self, iprot):
4836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4838 
      return
4839 
    iprot.readStructBegin()
4840 
    while True:
4841 
      (fname, ftype, fid) = iprot.readFieldBegin()
4842 
      if ftype == TType.STOP:
4843 
        break
4844 
      if fid == 1:
559 chandransh 4845 
        if ftype == TType.STRING:
4846 
          self.jsessionId = iprot.readString();
94 ashish 4847 
        else:
4848 
          iprot.skip(ftype)
4849 
      else:
4850 
        iprot.skip(ftype)
4851 
      iprot.readFieldEnd()
4852 
    iprot.readStructEnd()
4853 
 
4854 
  def write(self, oprot):
4855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4857 
      return
559 chandransh 4858 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 4859 
    if self.jsessionId is not None:
559 chandransh 4860 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4861 
      oprot.writeString(self.jsessionId)
94 ashish 4862 
      oprot.writeFieldEnd()
4863 
    oprot.writeFieldStop()
4864 
    oprot.writeStructEnd()
4865 
 
3431 rajveer 4866 
  def validate(self):
4867 
    return
4868 
 
4869 
 
94 ashish 4870 
  def __repr__(self):
4871 
    L = ['%s=%r' % (key, value)
4872 
      for key, value in self.__dict__.iteritems()]
4873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4874 
 
4875 
  def __eq__(self, other):
4876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4877 
 
4878 
  def __ne__(self, other):
4879 
    return not (self == other)
4880 
 
559 chandransh 4881 
class createAnonymousUser_result:
94 ashish 4882 
  """
4883 
  Attributes:
4884 
   - success
559 chandransh 4885 
   - ucex
94 ashish 4886 
  """
4887 
 
4888 
  thrift_spec = (
559 chandransh 4889 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4890 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4891 
  )
4892 
 
559 chandransh 4893 
  def __init__(self, success=None, ucex=None,):
94 ashish 4894 
    self.success = success
559 chandransh 4895 
    self.ucex = ucex
94 ashish 4896 
 
4897 
  def read(self, iprot):
4898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4900 
      return
4901 
    iprot.readStructBegin()
4902 
    while True:
4903 
      (fname, ftype, fid) = iprot.readFieldBegin()
4904 
      if ftype == TType.STOP:
4905 
        break
4906 
      if fid == 0:
4907 
        if ftype == TType.STRUCT:
559 chandransh 4908 
          self.success = User()
94 ashish 4909 
          self.success.read(iprot)
4910 
        else:
4911 
          iprot.skip(ftype)
4912 
      elif fid == 1:
4913 
        if ftype == TType.STRUCT:
559 chandransh 4914 
          self.ucex = UserContextException()
4915 
          self.ucex.read(iprot)
94 ashish 4916 
        else:
4917 
          iprot.skip(ftype)
4918 
      else:
4919 
        iprot.skip(ftype)
4920 
      iprot.readFieldEnd()
4921 
    iprot.readStructEnd()
4922 
 
4923 
  def write(self, oprot):
4924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4926 
      return
559 chandransh 4927 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 4928 
    if self.success is not None:
94 ashish 4929 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4930 
      self.success.write(oprot)
4931 
      oprot.writeFieldEnd()
3431 rajveer 4932 
    if self.ucex is not None:
559 chandransh 4933 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4934 
      self.ucex.write(oprot)
94 ashish 4935 
      oprot.writeFieldEnd()
4936 
    oprot.writeFieldStop()
4937 
    oprot.writeStructEnd()
4938 
 
3431 rajveer 4939 
  def validate(self):
4940 
    return
4941 
 
4942 
 
94 ashish 4943 
  def __repr__(self):
4944 
    L = ['%s=%r' % (key, value)
4945 
      for key, value in self.__dict__.iteritems()]
4946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4947 
 
4948 
  def __eq__(self, other):
4949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4950 
 
4951 
  def __ne__(self, other):
4952 
    return not (self == other)
4953 
 
559 chandransh 4954 
class getUserById_args:
94 ashish 4955 
  """
4956 
  Attributes:
4957 
   - userId
4958 
  """
4959 
 
4960 
  thrift_spec = (
4961 
    None, # 0
4962 
    (1, TType.I64, 'userId', None, None, ), # 1
4963 
  )
4964 
 
559 chandransh 4965 
  def __init__(self, userId=None,):
94 ashish 4966 
    self.userId = userId
4967 
 
4968 
  def read(self, iprot):
4969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4971 
      return
4972 
    iprot.readStructBegin()
4973 
    while True:
4974 
      (fname, ftype, fid) = iprot.readFieldBegin()
4975 
      if ftype == TType.STOP:
4976 
        break
4977 
      if fid == 1:
4978 
        if ftype == TType.I64:
4979 
          self.userId = iprot.readI64();
4980 
        else:
4981 
          iprot.skip(ftype)
4982 
      else:
4983 
        iprot.skip(ftype)
4984 
      iprot.readFieldEnd()
4985 
    iprot.readStructEnd()
4986 
 
4987 
  def write(self, oprot):
4988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4990 
      return
559 chandransh 4991 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 4992 
    if self.userId is not None:
94 ashish 4993 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4994 
      oprot.writeI64(self.userId)
4995 
      oprot.writeFieldEnd()
4996 
    oprot.writeFieldStop()
4997 
    oprot.writeStructEnd()
4998 
 
3431 rajveer 4999 
  def validate(self):
5000 
    return
5001 
 
5002 
 
94 ashish 5003 
  def __repr__(self):
5004 
    L = ['%s=%r' % (key, value)
5005 
      for key, value in self.__dict__.iteritems()]
5006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5007 
 
5008 
  def __eq__(self, other):
5009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5010 
 
5011 
  def __ne__(self, other):
5012 
    return not (self == other)
5013 
 
559 chandransh 5014 
class getUserById_result:
94 ashish 5015 
  """
5016 
  Attributes:
5017 
   - success
559 chandransh 5018 
   - ucex
94 ashish 5019 
  """
5020 
 
5021 
  thrift_spec = (
559 chandransh 5022 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5023 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5024 
  )
5025 
 
559 chandransh 5026 
  def __init__(self, success=None, ucex=None,):
94 ashish 5027 
    self.success = success
559 chandransh 5028 
    self.ucex = ucex
94 ashish 5029 
 
5030 
  def read(self, iprot):
5031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5033 
      return
5034 
    iprot.readStructBegin()
5035 
    while True:
5036 
      (fname, ftype, fid) = iprot.readFieldBegin()
5037 
      if ftype == TType.STOP:
5038 
        break
5039 
      if fid == 0:
5040 
        if ftype == TType.STRUCT:
559 chandransh 5041 
          self.success = User()
94 ashish 5042 
          self.success.read(iprot)
5043 
        else:
5044 
          iprot.skip(ftype)
5045 
      elif fid == 1:
5046 
        if ftype == TType.STRUCT:
559 chandransh 5047 
          self.ucex = UserContextException()
5048 
          self.ucex.read(iprot)
94 ashish 5049 
        else:
5050 
          iprot.skip(ftype)
5051 
      else:
5052 
        iprot.skip(ftype)
5053 
      iprot.readFieldEnd()
5054 
    iprot.readStructEnd()
5055 
 
5056 
  def write(self, oprot):
5057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5059 
      return
559 chandransh 5060 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5061 
    if self.success is not None:
94 ashish 5062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5063 
      self.success.write(oprot)
5064 
      oprot.writeFieldEnd()
3431 rajveer 5065 
    if self.ucex is not None:
559 chandransh 5066 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5067 
      self.ucex.write(oprot)
94 ashish 5068 
      oprot.writeFieldEnd()
5069 
    oprot.writeFieldStop()
5070 
    oprot.writeStructEnd()
5071 
 
3431 rajveer 5072 
  def validate(self):
5073 
    return
5074 
 
5075 
 
94 ashish 5076 
  def __repr__(self):
5077 
    L = ['%s=%r' % (key, value)
5078 
      for key, value in self.__dict__.iteritems()]
5079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5080 
 
5081 
  def __eq__(self, other):
5082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5083 
 
5084 
  def __ne__(self, other):
5085 
    return not (self == other)
5086 
 
5326 rajveer 5087 
class getUserByCartId_args:
1491 vikas 5088 
  """
5089 
  Attributes:
5326 rajveer 5090 
   - cartId
1491 vikas 5091 
  """
5092 
 
5093 
  thrift_spec = (
5094 
    None, # 0
5326 rajveer 5095 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5096 
  )
5097 
 
5326 rajveer 5098 
  def __init__(self, cartId=None,):
5099 
    self.cartId = cartId
1491 vikas 5100 
 
5101 
  def read(self, iprot):
5102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5104 
      return
5105 
    iprot.readStructBegin()
5106 
    while True:
5107 
      (fname, ftype, fid) = iprot.readFieldBegin()
5108 
      if ftype == TType.STOP:
5109 
        break
5110 
      if fid == 1:
5326 rajveer 5111 
        if ftype == TType.I64:
5112 
          self.cartId = iprot.readI64();
1491 vikas 5113 
        else:
5114 
          iprot.skip(ftype)
5115 
      else:
5116 
        iprot.skip(ftype)
5117 
      iprot.readFieldEnd()
5118 
    iprot.readStructEnd()
5119 
 
5120 
  def write(self, oprot):
5121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5123 
      return
5326 rajveer 5124 
    oprot.writeStructBegin('getUserByCartId_args')
5125 
    if self.cartId is not None:
5126 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5127 
      oprot.writeI64(self.cartId)
1491 vikas 5128 
      oprot.writeFieldEnd()
5129 
    oprot.writeFieldStop()
5130 
    oprot.writeStructEnd()
5131 
 
3431 rajveer 5132 
  def validate(self):
5133 
    return
5134 
 
5135 
 
1491 vikas 5136 
  def __repr__(self):
5137 
    L = ['%s=%r' % (key, value)
5138 
      for key, value in self.__dict__.iteritems()]
5139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5140 
 
5141 
  def __eq__(self, other):
5142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5143 
 
5144 
  def __ne__(self, other):
5145 
    return not (self == other)
5146 
 
5326 rajveer 5147 
class getUserByCartId_result:
1491 vikas 5148 
  """
5149 
  Attributes:
5150 
   - success
5151 
   - ucex
5152 
  """
5153 
 
5154 
  thrift_spec = (
5155 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5156 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5157 
  )
5158 
 
5159 
  def __init__(self, success=None, ucex=None,):
5160 
    self.success = success
5161 
    self.ucex = ucex
5162 
 
5163 
  def read(self, iprot):
5164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5166 
      return
5167 
    iprot.readStructBegin()
5168 
    while True:
5169 
      (fname, ftype, fid) = iprot.readFieldBegin()
5170 
      if ftype == TType.STOP:
5171 
        break
5172 
      if fid == 0:
5173 
        if ftype == TType.STRUCT:
5174 
          self.success = User()
5175 
          self.success.read(iprot)
5176 
        else:
5177 
          iprot.skip(ftype)
5178 
      elif fid == 1:
5179 
        if ftype == TType.STRUCT:
5180 
          self.ucex = UserContextException()
5181 
          self.ucex.read(iprot)
5182 
        else:
5183 
          iprot.skip(ftype)
5184 
      else:
5185 
        iprot.skip(ftype)
5186 
      iprot.readFieldEnd()
5187 
    iprot.readStructEnd()
5188 
 
5189 
  def write(self, oprot):
5190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5192 
      return
5326 rajveer 5193 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5194 
    if self.success is not None:
1491 vikas 5195 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5196 
      self.success.write(oprot)
5197 
      oprot.writeFieldEnd()
3431 rajveer 5198 
    if self.ucex is not None:
1491 vikas 5199 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5200 
      self.ucex.write(oprot)
5201 
      oprot.writeFieldEnd()
5202 
    oprot.writeFieldStop()
5203 
    oprot.writeStructEnd()
5204 
 
3431 rajveer 5205 
  def validate(self):
5206 
    return
5207 
 
5208 
 
1491 vikas 5209 
  def __repr__(self):
5210 
    L = ['%s=%r' % (key, value)
5211 
      for key, value in self.__dict__.iteritems()]
5212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5213 
 
5214 
  def __eq__(self, other):
5215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5216 
 
5217 
  def __ne__(self, other):
5218 
    return not (self == other)
5219 
 
5326 rajveer 5220 
class getUserByEmail_args:
3032 mandeep.dh 5221 
  """
5222 
  Attributes:
5326 rajveer 5223 
   - email
3032 mandeep.dh 5224 
  """
5225 
 
5226 
  thrift_spec = (
5227 
    None, # 0
5326 rajveer 5228 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5229 
  )
5230 
 
5326 rajveer 5231 
  def __init__(self, email=None,):
5232 
    self.email = email
3032 mandeep.dh 5233 
 
5234 
  def read(self, iprot):
5235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5237 
      return
5238 
    iprot.readStructBegin()
5239 
    while True:
5240 
      (fname, ftype, fid) = iprot.readFieldBegin()
5241 
      if ftype == TType.STOP:
5242 
        break
5243 
      if fid == 1:
5326 rajveer 5244 
        if ftype == TType.STRING:
5245 
          self.email = iprot.readString();
3032 mandeep.dh 5246 
        else:
5247 
          iprot.skip(ftype)
5248 
      else:
5249 
        iprot.skip(ftype)
5250 
      iprot.readFieldEnd()
5251 
    iprot.readStructEnd()
5252 
 
5253 
  def write(self, oprot):
5254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5256 
      return
5326 rajveer 5257 
    oprot.writeStructBegin('getUserByEmail_args')
5258 
    if self.email is not None:
5259 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5260 
      oprot.writeString(self.email)
3032 mandeep.dh 5261 
      oprot.writeFieldEnd()
5262 
    oprot.writeFieldStop()
5263 
    oprot.writeStructEnd()
5264 
 
3431 rajveer 5265 
  def validate(self):
5266 
    return
5267 
 
5268 
 
3032 mandeep.dh 5269 
  def __repr__(self):
5270 
    L = ['%s=%r' % (key, value)
5271 
      for key, value in self.__dict__.iteritems()]
5272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5273 
 
5274 
  def __eq__(self, other):
5275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5276 
 
5277 
  def __ne__(self, other):
5278 
    return not (self == other)
5279 
 
5326 rajveer 5280 
class getUserByEmail_result:
3032 mandeep.dh 5281 
  """
5282 
  Attributes:
5283 
   - success
5284 
   - ucex
5285 
  """
5286 
 
5287 
  thrift_spec = (
5288 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5289 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5290 
  )
5291 
 
5292 
  def __init__(self, success=None, ucex=None,):
5293 
    self.success = success
5294 
    self.ucex = ucex
5295 
 
5296 
  def read(self, iprot):
5297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5299 
      return
5300 
    iprot.readStructBegin()
5301 
    while True:
5302 
      (fname, ftype, fid) = iprot.readFieldBegin()
5303 
      if ftype == TType.STOP:
5304 
        break
5305 
      if fid == 0:
5306 
        if ftype == TType.STRUCT:
5307 
          self.success = User()
5308 
          self.success.read(iprot)
5309 
        else:
5310 
          iprot.skip(ftype)
5311 
      elif fid == 1:
5312 
        if ftype == TType.STRUCT:
5313 
          self.ucex = UserContextException()
5314 
          self.ucex.read(iprot)
5315 
        else:
5316 
          iprot.skip(ftype)
5317 
      else:
5318 
        iprot.skip(ftype)
5319 
      iprot.readFieldEnd()
5320 
    iprot.readStructEnd()
5321 
 
5322 
  def write(self, oprot):
5323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5325 
      return
5326 rajveer 5326 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5327 
    if self.success is not None:
3032 mandeep.dh 5328 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5329 
      self.success.write(oprot)
5330 
      oprot.writeFieldEnd()
3431 rajveer 5331 
    if self.ucex is not None:
3032 mandeep.dh 5332 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5333 
      self.ucex.write(oprot)
5334 
      oprot.writeFieldEnd()
5335 
    oprot.writeFieldStop()
5336 
    oprot.writeStructEnd()
5337 
 
3431 rajveer 5338 
  def validate(self):
5339 
    return
5340 
 
5341 
 
3032 mandeep.dh 5342 
  def __repr__(self):
5343 
    L = ['%s=%r' % (key, value)
5344 
      for key, value in self.__dict__.iteritems()]
5345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5346 
 
5347 
  def __eq__(self, other):
5348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5349 
 
5350 
  def __ne__(self, other):
5351 
    return not (self == other)
5352 
 
5326 rajveer 5353 
class getUserByMobileNumber_args:
94 ashish 5354 
  """
5355 
  Attributes:
5326 rajveer 5356 
   - mobileNumber
94 ashish 5357 
  """
5358 
 
5359 
  thrift_spec = (
5360 
    None, # 0
5326 rajveer 5361 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5362 
  )
5363 
 
5326 rajveer 5364 
  def __init__(self, mobileNumber=None,):
5365 
    self.mobileNumber = mobileNumber
94 ashish 5366 
 
5367 
  def read(self, iprot):
5368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5370 
      return
5371 
    iprot.readStructBegin()
5372 
    while True:
5373 
      (fname, ftype, fid) = iprot.readFieldBegin()
5374 
      if ftype == TType.STOP:
5375 
        break
5376 
      if fid == 1:
5326 rajveer 5377 
        if ftype == TType.I64:
5378 
          self.mobileNumber = iprot.readI64();
94 ashish 5379 
        else:
5380 
          iprot.skip(ftype)
5381 
      else:
5382 
        iprot.skip(ftype)
5383 
      iprot.readFieldEnd()
5384 
    iprot.readStructEnd()
5385 
 
5386 
  def write(self, oprot):
5387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5389 
      return
5326 rajveer 5390 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5391 
    if self.mobileNumber is not None:
5392 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5393 
      oprot.writeI64(self.mobileNumber)
94 ashish 5394 
      oprot.writeFieldEnd()
5395 
    oprot.writeFieldStop()
5396 
    oprot.writeStructEnd()
5397 
 
3431 rajveer 5398 
  def validate(self):
5399 
    return
5400 
 
5401 
 
94 ashish 5402 
  def __repr__(self):
5403 
    L = ['%s=%r' % (key, value)
5404 
      for key, value in self.__dict__.iteritems()]
5405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5406 
 
5407 
  def __eq__(self, other):
5408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5409 
 
5410 
  def __ne__(self, other):
5411 
    return not (self == other)
5412 
 
5326 rajveer 5413 
class getUserByMobileNumber_result:
94 ashish 5414 
  """
5415 
  Attributes:
5416 
   - success
559 chandransh 5417 
   - ucex
94 ashish 5418 
  """
5419 
 
5420 
  thrift_spec = (
559 chandransh 5421 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5422 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5423 
  )
5424 
 
559 chandransh 5425 
  def __init__(self, success=None, ucex=None,):
94 ashish 5426 
    self.success = success
559 chandransh 5427 
    self.ucex = ucex
94 ashish 5428 
 
5429 
  def read(self, iprot):
5430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5432 
      return
5433 
    iprot.readStructBegin()
5434 
    while True:
5435 
      (fname, ftype, fid) = iprot.readFieldBegin()
5436 
      if ftype == TType.STOP:
5437 
        break
5438 
      if fid == 0:
5439 
        if ftype == TType.STRUCT:
559 chandransh 5440 
          self.success = User()
94 ashish 5441 
          self.success.read(iprot)
5442 
        else:
5443 
          iprot.skip(ftype)
5444 
      elif fid == 1:
5445 
        if ftype == TType.STRUCT:
559 chandransh 5446 
          self.ucex = UserContextException()
5447 
          self.ucex.read(iprot)
94 ashish 5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      else:
5451 
        iprot.skip(ftype)
5452 
      iprot.readFieldEnd()
5453 
    iprot.readStructEnd()
5454 
 
5455 
  def write(self, oprot):
5456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5458 
      return
5326 rajveer 5459 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5460 
    if self.success is not None:
94 ashish 5461 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5462 
      self.success.write(oprot)
5463 
      oprot.writeFieldEnd()
3431 rajveer 5464 
    if self.ucex is not None:
559 chandransh 5465 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5466 
      self.ucex.write(oprot)
94 ashish 5467 
      oprot.writeFieldEnd()
5468 
    oprot.writeFieldStop()
5469 
    oprot.writeStructEnd()
5470 
 
3431 rajveer 5471 
  def validate(self):
5472 
    return
5473 
 
5474 
 
94 ashish 5475 
  def __repr__(self):
5476 
    L = ['%s=%r' % (key, value)
5477 
      for key, value in self.__dict__.iteritems()]
5478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5479 
 
5480 
  def __eq__(self, other):
5481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5482 
 
5483 
  def __ne__(self, other):
5484 
    return not (self == other)
5485 
 
5326 rajveer 5486 
class createUser_args:
94 ashish 5487 
  """
5488 
  Attributes:
559 chandransh 5489 
   - user
94 ashish 5490 
  """
5491 
 
5492 
  thrift_spec = (
5493 
    None, # 0
559 chandransh 5494 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5495 
  )
5496 
 
559 chandransh 5497 
  def __init__(self, user=None,):
5498 
    self.user = user
94 ashish 5499 
 
5500 
  def read(self, iprot):
5501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5503 
      return
5504 
    iprot.readStructBegin()
5505 
    while True:
5506 
      (fname, ftype, fid) = iprot.readFieldBegin()
5507 
      if ftype == TType.STOP:
5508 
        break
5509 
      if fid == 1:
559 chandransh 5510 
        if ftype == TType.STRUCT:
5511 
          self.user = User()
5512 
          self.user.read(iprot)
94 ashish 5513 
        else:
5514 
          iprot.skip(ftype)
5515 
      else:
5516 
        iprot.skip(ftype)
5517 
      iprot.readFieldEnd()
5518 
    iprot.readStructEnd()
5519 
 
5520 
  def write(self, oprot):
5521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5523 
      return
5326 rajveer 5524 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5525 
    if self.user is not None:
559 chandransh 5526 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5527 
      self.user.write(oprot)
94 ashish 5528 
      oprot.writeFieldEnd()
5529 
    oprot.writeFieldStop()
5530 
    oprot.writeStructEnd()
5531 
 
3431 rajveer 5532 
  def validate(self):
5533 
    return
5534 
 
5535 
 
94 ashish 5536 
  def __repr__(self):
5537 
    L = ['%s=%r' % (key, value)
5538 
      for key, value in self.__dict__.iteritems()]
5539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5540 
 
5541 
  def __eq__(self, other):
5542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5543 
 
5544 
  def __ne__(self, other):
5545 
    return not (self == other)
5546 
 
5326 rajveer 5547 
class createUser_result:
94 ashish 5548 
  """
5549 
  Attributes:
5550 
   - success
559 chandransh 5551 
   - ucex
94 ashish 5552 
  """
5553 
 
5554 
  thrift_spec = (
559 chandransh 5555 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5556 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5557 
  )
5558 
 
559 chandransh 5559 
  def __init__(self, success=None, ucex=None,):
94 ashish 5560 
    self.success = success
559 chandransh 5561 
    self.ucex = ucex
94 ashish 5562 
 
5563 
  def read(self, iprot):
5564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5566 
      return
5567 
    iprot.readStructBegin()
5568 
    while True:
5569 
      (fname, ftype, fid) = iprot.readFieldBegin()
5570 
      if ftype == TType.STOP:
5571 
        break
5572 
      if fid == 0:
5573 
        if ftype == TType.STRUCT:
559 chandransh 5574 
          self.success = User()
94 ashish 5575 
          self.success.read(iprot)
5576 
        else:
5577 
          iprot.skip(ftype)
5578 
      elif fid == 1:
5579 
        if ftype == TType.STRUCT:
559 chandransh 5580 
          self.ucex = UserContextException()
5581 
          self.ucex.read(iprot)
94 ashish 5582 
        else:
5583 
          iprot.skip(ftype)
5584 
      else:
5585 
        iprot.skip(ftype)
5586 
      iprot.readFieldEnd()
5587 
    iprot.readStructEnd()
5588 
 
5589 
  def write(self, oprot):
5590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5592 
      return
5326 rajveer 5593 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5594 
    if self.success is not None:
94 ashish 5595 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5596 
      self.success.write(oprot)
5597 
      oprot.writeFieldEnd()
3431 rajveer 5598 
    if self.ucex is not None:
559 chandransh 5599 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5600 
      self.ucex.write(oprot)
94 ashish 5601 
      oprot.writeFieldEnd()
5602 
    oprot.writeFieldStop()
5603 
    oprot.writeStructEnd()
5604 
 
3431 rajveer 5605 
  def validate(self):
5606 
    return
5607 
 
5608 
 
94 ashish 5609 
  def __repr__(self):
5610 
    L = ['%s=%r' % (key, value)
5611 
      for key, value in self.__dict__.iteritems()]
5612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5613 
 
5614 
  def __eq__(self, other):
5615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5616 
 
5617 
  def __ne__(self, other):
5618 
    return not (self == other)
5619 
 
5326 rajveer 5620 
class updateUser_args:
94 ashish 5621 
  """
5622 
  Attributes:
5326 rajveer 5623 
   - user
94 ashish 5624 
  """
5625 
 
5626 
  thrift_spec = (
5627 
    None, # 0
5326 rajveer 5628 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5629 
  )
5630 
 
5326 rajveer 5631 
  def __init__(self, user=None,):
5632 
    self.user = user
94 ashish 5633 
 
5634 
  def read(self, iprot):
5635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5637 
      return
5638 
    iprot.readStructBegin()
5639 
    while True:
5640 
      (fname, ftype, fid) = iprot.readFieldBegin()
5641 
      if ftype == TType.STOP:
5642 
        break
5643 
      if fid == 1:
5326 rajveer 5644 
        if ftype == TType.STRUCT:
5645 
          self.user = User()
5646 
          self.user.read(iprot)
94 ashish 5647 
        else:
5648 
          iprot.skip(ftype)
5649 
      else:
5650 
        iprot.skip(ftype)
5651 
      iprot.readFieldEnd()
5652 
    iprot.readStructEnd()
5653 
 
5654 
  def write(self, oprot):
5655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5657 
      return
5326 rajveer 5658 
    oprot.writeStructBegin('updateUser_args')
5659 
    if self.user is not None:
5660 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5661 
      self.user.write(oprot)
94 ashish 5662 
      oprot.writeFieldEnd()
5663 
    oprot.writeFieldStop()
5664 
    oprot.writeStructEnd()
5665 
 
3431 rajveer 5666 
  def validate(self):
5667 
    return
5668 
 
5669 
 
94 ashish 5670 
  def __repr__(self):
5671 
    L = ['%s=%r' % (key, value)
5672 
      for key, value in self.__dict__.iteritems()]
5673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5674 
 
5675 
  def __eq__(self, other):
5676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5677 
 
5678 
  def __ne__(self, other):
5679 
    return not (self == other)
5680 
 
5326 rajveer 5681 
class updateUser_result:
94 ashish 5682 
  """
5683 
  Attributes:
5684 
   - success
559 chandransh 5685 
   - ucex
94 ashish 5686 
  """
5687 
 
5688 
  thrift_spec = (
5326 rajveer 5689 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5690 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5691 
  )
5692 
 
559 chandransh 5693 
  def __init__(self, success=None, ucex=None,):
94 ashish 5694 
    self.success = success
559 chandransh 5695 
    self.ucex = ucex
94 ashish 5696 
 
5697 
  def read(self, iprot):
5698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5700 
      return
5701 
    iprot.readStructBegin()
5702 
    while True:
5703 
      (fname, ftype, fid) = iprot.readFieldBegin()
5704 
      if ftype == TType.STOP:
5705 
        break
5706 
      if fid == 0:
5326 rajveer 5707 
        if ftype == TType.STRUCT:
5708 
          self.success = User()
5709 
          self.success.read(iprot)
94 ashish 5710 
        else:
5711 
          iprot.skip(ftype)
5712 
      elif fid == 1:
5713 
        if ftype == TType.STRUCT:
559 chandransh 5714 
          self.ucex = UserContextException()
5715 
          self.ucex.read(iprot)
94 ashish 5716 
        else:
5717 
          iprot.skip(ftype)
5718 
      else:
5719 
        iprot.skip(ftype)
5720 
      iprot.readFieldEnd()
5721 
    iprot.readStructEnd()
5722 
 
5723 
  def write(self, oprot):
5724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5726 
      return
5326 rajveer 5727 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 5728 
    if self.success is not None:
5326 rajveer 5729 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5730 
      self.success.write(oprot)
94 ashish 5731 
      oprot.writeFieldEnd()
3431 rajveer 5732 
    if self.ucex is not None:
559 chandransh 5733 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5734 
      self.ucex.write(oprot)
94 ashish 5735 
      oprot.writeFieldEnd()
5736 
    oprot.writeFieldStop()
5737 
    oprot.writeStructEnd()
5738 
 
3431 rajveer 5739 
  def validate(self):
5740 
    return
5741 
 
5742 
 
94 ashish 5743 
  def __repr__(self):
5744 
    L = ['%s=%r' % (key, value)
5745 
      for key, value in self.__dict__.iteritems()]
5746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5747 
 
5748 
  def __eq__(self, other):
5749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5750 
 
5751 
  def __ne__(self, other):
5752 
    return not (self == other)
5753 
 
559 chandransh 5754 
class authenticateUser_args:
94 ashish 5755 
  """
5756 
  Attributes:
5757 
   - email
5758 
   - password
5759 
  """
5760 
 
5761 
  thrift_spec = (
5762 
    None, # 0
5763 
    (1, TType.STRING, 'email', None, None, ), # 1
5764 
    (2, TType.STRING, 'password', None, None, ), # 2
5765 
  )
5766 
 
5767 
  def __init__(self, email=None, password=None,):
5768 
    self.email = email
5769 
    self.password = password
5770 
 
5771 
  def read(self, iprot):
5772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5774 
      return
5775 
    iprot.readStructBegin()
5776 
    while True:
5777 
      (fname, ftype, fid) = iprot.readFieldBegin()
5778 
      if ftype == TType.STOP:
5779 
        break
5780 
      if fid == 1:
5781 
        if ftype == TType.STRING:
5782 
          self.email = iprot.readString();
5783 
        else:
5784 
          iprot.skip(ftype)
5785 
      elif fid == 2:
5786 
        if ftype == TType.STRING:
5787 
          self.password = iprot.readString();
5788 
        else:
5789 
          iprot.skip(ftype)
5790 
      else:
5791 
        iprot.skip(ftype)
5792 
      iprot.readFieldEnd()
5793 
    iprot.readStructEnd()
5794 
 
5795 
  def write(self, oprot):
5796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5798 
      return
559 chandransh 5799 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 5800 
    if self.email is not None:
94 ashish 5801 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5802 
      oprot.writeString(self.email)
5803 
      oprot.writeFieldEnd()
3431 rajveer 5804 
    if self.password is not None:
94 ashish 5805 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5806 
      oprot.writeString(self.password)
5807 
      oprot.writeFieldEnd()
5808 
    oprot.writeFieldStop()
5809 
    oprot.writeStructEnd()
5810 
 
3431 rajveer 5811 
  def validate(self):
5812 
    return
5813 
 
5814 
 
94 ashish 5815 
  def __repr__(self):
5816 
    L = ['%s=%r' % (key, value)
5817 
      for key, value in self.__dict__.iteritems()]
5818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5819 
 
5820 
  def __eq__(self, other):
5821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5822 
 
5823 
  def __ne__(self, other):
5824 
    return not (self == other)
5825 
 
559 chandransh 5826 
class authenticateUser_result:
94 ashish 5827 
  """
5828 
  Attributes:
5829 
   - success
559 chandransh 5830 
   - auex
94 ashish 5831 
  """
5832 
 
5833 
  thrift_spec = (
559 chandransh 5834 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5835 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5836 
  )
5837 
 
559 chandransh 5838 
  def __init__(self, success=None, auex=None,):
94 ashish 5839 
    self.success = success
559 chandransh 5840 
    self.auex = auex
94 ashish 5841 
 
5842 
  def read(self, iprot):
5843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5845 
      return
5846 
    iprot.readStructBegin()
5847 
    while True:
5848 
      (fname, ftype, fid) = iprot.readFieldBegin()
5849 
      if ftype == TType.STOP:
5850 
        break
5851 
      if fid == 0:
5852 
        if ftype == TType.STRUCT:
559 chandransh 5853 
          self.success = User()
94 ashish 5854 
          self.success.read(iprot)
5855 
        else:
5856 
          iprot.skip(ftype)
5857 
      elif fid == 1:
5858 
        if ftype == TType.STRUCT:
559 chandransh 5859 
          self.auex = AuthenticationException()
5860 
          self.auex.read(iprot)
94 ashish 5861 
        else:
5862 
          iprot.skip(ftype)
5863 
      else:
5864 
        iprot.skip(ftype)
5865 
      iprot.readFieldEnd()
5866 
    iprot.readStructEnd()
5867 
 
5868 
  def write(self, oprot):
5869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5871 
      return
559 chandransh 5872 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 5873 
    if self.success is not None:
94 ashish 5874 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5875 
      self.success.write(oprot)
5876 
      oprot.writeFieldEnd()
3431 rajveer 5877 
    if self.auex is not None:
559 chandransh 5878 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5879 
      self.auex.write(oprot)
94 ashish 5880 
      oprot.writeFieldEnd()
5881 
    oprot.writeFieldStop()
5882 
    oprot.writeStructEnd()
5883 
 
3431 rajveer 5884 
  def validate(self):
5885 
    return
5886 
 
5887 
 
94 ashish 5888 
  def __repr__(self):
5889 
    L = ['%s=%r' % (key, value)
5890 
      for key, value in self.__dict__.iteritems()]
5891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5892 
 
5893 
  def __eq__(self, other):
5894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5895 
 
5896 
  def __ne__(self, other):
5897 
    return not (self == other)
5898 
 
559 chandransh 5899 
class userExists_args:
122 ashish 5900 
  """
5901 
  Attributes:
559 chandransh 5902 
   - email
122 ashish 5903 
  """
5904 
 
5905 
  thrift_spec = (
5906 
    None, # 0
559 chandransh 5907 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5908 
  )
5909 
 
559 chandransh 5910 
  def __init__(self, email=None,):
5911 
    self.email = email
122 ashish 5912 
 
5913 
  def read(self, iprot):
5914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5916 
      return
5917 
    iprot.readStructBegin()
5918 
    while True:
5919 
      (fname, ftype, fid) = iprot.readFieldBegin()
5920 
      if ftype == TType.STOP:
5921 
        break
5922 
      if fid == 1:
5923 
        if ftype == TType.STRING:
559 chandransh 5924 
          self.email = iprot.readString();
122 ashish 5925 
        else:
5926 
          iprot.skip(ftype)
559 chandransh 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
5936 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 5937 
    if self.email is not None:
559 chandransh 5938 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5939 
      oprot.writeString(self.email)
5940 
      oprot.writeFieldEnd()
5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
3431 rajveer 5944 
  def validate(self):
5945 
    return
5946 
 
5947 
 
559 chandransh 5948 
  def __repr__(self):
5949 
    L = ['%s=%r' % (key, value)
5950 
      for key, value in self.__dict__.iteritems()]
5951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5952 
 
5953 
  def __eq__(self, other):
5954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5955 
 
5956 
  def __ne__(self, other):
5957 
    return not (self == other)
5958 
 
5959 
class userExists_result:
5960 
  """
5961 
  Attributes:
5962 
   - success
5963 
   - ucx
5964 
  """
5965 
 
5966 
  thrift_spec = (
5967 
    (0, TType.BOOL, 'success', None, None, ), # 0
5968 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5969 
  )
5970 
 
5971 
  def __init__(self, success=None, ucx=None,):
5972 
    self.success = success
5973 
    self.ucx = ucx
5974 
 
5975 
  def read(self, iprot):
5976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5978 
      return
5979 
    iprot.readStructBegin()
5980 
    while True:
5981 
      (fname, ftype, fid) = iprot.readFieldBegin()
5982 
      if ftype == TType.STOP:
5983 
        break
5984 
      if fid == 0:
5985 
        if ftype == TType.BOOL:
5986 
          self.success = iprot.readBool();
5987 
        else:
5988 
          iprot.skip(ftype)
5989 
      elif fid == 1:
5990 
        if ftype == TType.STRUCT:
5991 
          self.ucx = UserContextException()
5992 
          self.ucx.read(iprot)
5993 
        else:
5994 
          iprot.skip(ftype)
5995 
      else:
5996 
        iprot.skip(ftype)
5997 
      iprot.readFieldEnd()
5998 
    iprot.readStructEnd()
5999 
 
6000 
  def write(self, oprot):
6001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6003 
      return
6004 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6005 
    if self.success is not None:
559 chandransh 6006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6007 
      oprot.writeBool(self.success)
6008 
      oprot.writeFieldEnd()
3431 rajveer 6009 
    if self.ucx is not None:
559 chandransh 6010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6011 
      self.ucx.write(oprot)
6012 
      oprot.writeFieldEnd()
6013 
    oprot.writeFieldStop()
6014 
    oprot.writeStructEnd()
6015 
 
3431 rajveer 6016 
  def validate(self):
6017 
    return
6018 
 
6019 
 
559 chandransh 6020 
  def __repr__(self):
6021 
    L = ['%s=%r' % (key, value)
6022 
      for key, value in self.__dict__.iteritems()]
6023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6024 
 
6025 
  def __eq__(self, other):
6026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6027 
 
6028 
  def __ne__(self, other):
6029 
    return not (self == other)
6030 
 
6031 
class addAddressForUser_args:
6032 
  """
6033 
  Attributes:
6034 
   - userId
6035 
   - address
6036 
   - setDefault
6037 
  """
6038 
 
6039 
  thrift_spec = (
6040 
    None, # 0
6041 
    (1, TType.I64, 'userId', None, None, ), # 1
6042 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6043 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6044 
  )
6045 
 
567 rajveer 6046 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6047 
    self.userId = userId
6048 
    self.address = address
6049 
    self.setDefault = setDefault
6050 
 
6051 
  def read(self, iprot):
6052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6054 
      return
6055 
    iprot.readStructBegin()
6056 
    while True:
6057 
      (fname, ftype, fid) = iprot.readFieldBegin()
6058 
      if ftype == TType.STOP:
6059 
        break
6060 
      if fid == 1:
6061 
        if ftype == TType.I64:
6062 
          self.userId = iprot.readI64();
6063 
        else:
6064 
          iprot.skip(ftype)
122 ashish 6065 
      elif fid == 2:
559 chandransh 6066 
        if ftype == TType.STRUCT:
6067 
          self.address = Address()
6068 
          self.address.read(iprot)
122 ashish 6069 
        else:
6070 
          iprot.skip(ftype)
6071 
      elif fid == 3:
6072 
        if ftype == TType.BOOL:
559 chandransh 6073 
          self.setDefault = iprot.readBool();
122 ashish 6074 
        else:
6075 
          iprot.skip(ftype)
6076 
      else:
6077 
        iprot.skip(ftype)
6078 
      iprot.readFieldEnd()
6079 
    iprot.readStructEnd()
6080 
 
6081 
  def write(self, oprot):
6082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6084 
      return
559 chandransh 6085 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6086 
    if self.userId is not None:
559 chandransh 6087 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6088 
      oprot.writeI64(self.userId)
122 ashish 6089 
      oprot.writeFieldEnd()
3431 rajveer 6090 
    if self.address is not None:
559 chandransh 6091 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6092 
      self.address.write(oprot)
122 ashish 6093 
      oprot.writeFieldEnd()
3431 rajveer 6094 
    if self.setDefault is not None:
567 rajveer 6095 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6096 
      oprot.writeBool(self.setDefault)
6097 
      oprot.writeFieldEnd()
122 ashish 6098 
    oprot.writeFieldStop()
6099 
    oprot.writeStructEnd()
6100 
 
3431 rajveer 6101 
  def validate(self):
6102 
    return
6103 
 
6104 
 
122 ashish 6105 
  def __repr__(self):
6106 
    L = ['%s=%r' % (key, value)
6107 
      for key, value in self.__dict__.iteritems()]
6108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6109 
 
6110 
  def __eq__(self, other):
6111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6112 
 
6113 
  def __ne__(self, other):
6114 
    return not (self == other)
6115 
 
559 chandransh 6116 
class addAddressForUser_result:
122 ashish 6117 
  """
6118 
  Attributes:
6119 
   - success
559 chandransh 6120 
   - ucx
122 ashish 6121 
  """
6122 
 
6123 
  thrift_spec = (
567 rajveer 6124 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6125 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6126 
  )
6127 
 
559 chandransh 6128 
  def __init__(self, success=None, ucx=None,):
122 ashish 6129 
    self.success = success
559 chandransh 6130 
    self.ucx = ucx
122 ashish 6131 
 
6132 
  def read(self, iprot):
6133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6135 
      return
6136 
    iprot.readStructBegin()
6137 
    while True:
6138 
      (fname, ftype, fid) = iprot.readFieldBegin()
6139 
      if ftype == TType.STOP:
6140 
        break
6141 
      if fid == 0:
567 rajveer 6142 
        if ftype == TType.I64:
6143 
          self.success = iprot.readI64();
122 ashish 6144 
        else:
6145 
          iprot.skip(ftype)
6146 
      elif fid == 1:
6147 
        if ftype == TType.STRUCT:
559 chandransh 6148 
          self.ucx = UserContextException()
6149 
          self.ucx.read(iprot)
122 ashish 6150 
        else:
6151 
          iprot.skip(ftype)
6152 
      else:
6153 
        iprot.skip(ftype)
6154 
      iprot.readFieldEnd()
6155 
    iprot.readStructEnd()
6156 
 
6157 
  def write(self, oprot):
6158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6160 
      return
559 chandransh 6161 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6162 
    if self.success is not None:
567 rajveer 6163 
      oprot.writeFieldBegin('success', TType.I64, 0)
6164 
      oprot.writeI64(self.success)
122 ashish 6165 
      oprot.writeFieldEnd()
3431 rajveer 6166 
    if self.ucx is not None:
559 chandransh 6167 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6168 
      self.ucx.write(oprot)
122 ashish 6169 
      oprot.writeFieldEnd()
6170 
    oprot.writeFieldStop()
6171 
    oprot.writeStructEnd()
6172 
 
3431 rajveer 6173 
  def validate(self):
6174 
    return
6175 
 
6176 
 
122 ashish 6177 
  def __repr__(self):
6178 
    L = ['%s=%r' % (key, value)
6179 
      for key, value in self.__dict__.iteritems()]
6180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6181 
 
6182 
  def __eq__(self, other):
6183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6184 
 
6185 
  def __ne__(self, other):
6186 
    return not (self == other)
6187 
 
559 chandransh 6188 
class removeAddressForUser_args:
94 ashish 6189 
  """
6190 
  Attributes:
559 chandransh 6191 
   - userid
6192 
   - addressId
94 ashish 6193 
  """
6194 
 
6195 
  thrift_spec = (
6196 
    None, # 0
559 chandransh 6197 
    (1, TType.I64, 'userid', None, None, ), # 1
6198 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6199 
  )
6200 
 
559 chandransh 6201 
  def __init__(self, userid=None, addressId=None,):
6202 
    self.userid = userid
6203 
    self.addressId = addressId
94 ashish 6204 
 
6205 
  def read(self, iprot):
6206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6208 
      return
6209 
    iprot.readStructBegin()
6210 
    while True:
6211 
      (fname, ftype, fid) = iprot.readFieldBegin()
6212 
      if ftype == TType.STOP:
6213 
        break
6214 
      if fid == 1:
559 chandransh 6215 
        if ftype == TType.I64:
6216 
          self.userid = iprot.readI64();
94 ashish 6217 
        else:
6218 
          iprot.skip(ftype)
559 chandransh 6219 
      elif fid == 2:
6220 
        if ftype == TType.I64:
6221 
          self.addressId = iprot.readI64();
6222 
        else:
6223 
          iprot.skip(ftype)
94 ashish 6224 
      else:
6225 
        iprot.skip(ftype)
6226 
      iprot.readFieldEnd()
6227 
    iprot.readStructEnd()
6228 
 
6229 
  def write(self, oprot):
6230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6232 
      return
559 chandransh 6233 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6234 
    if self.userid is not None:
559 chandransh 6235 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6236 
      oprot.writeI64(self.userid)
94 ashish 6237 
      oprot.writeFieldEnd()
3431 rajveer 6238 
    if self.addressId is not None:
559 chandransh 6239 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6240 
      oprot.writeI64(self.addressId)
6241 
      oprot.writeFieldEnd()
94 ashish 6242 
    oprot.writeFieldStop()
6243 
    oprot.writeStructEnd()
6244 
 
3431 rajveer 6245 
  def validate(self):
6246 
    return
6247 
 
6248 
 
94 ashish 6249 
  def __repr__(self):
6250 
    L = ['%s=%r' % (key, value)
6251 
      for key, value in self.__dict__.iteritems()]
6252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6253 
 
6254 
  def __eq__(self, other):
6255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6256 
 
6257 
  def __ne__(self, other):
6258 
    return not (self == other)
6259 
 
559 chandransh 6260 
class removeAddressForUser_result:
94 ashish 6261 
  """
6262 
  Attributes:
6263 
   - success
6264 
   - ucx
6265 
  """
6266 
 
6267 
  thrift_spec = (
6268 
    (0, TType.BOOL, 'success', None, None, ), # 0
6269 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6270 
  )
6271 
 
6272 
  def __init__(self, success=None, ucx=None,):
6273 
    self.success = success
6274 
    self.ucx = ucx
6275 
 
6276 
  def read(self, iprot):
6277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6279 
      return
6280 
    iprot.readStructBegin()
6281 
    while True:
6282 
      (fname, ftype, fid) = iprot.readFieldBegin()
6283 
      if ftype == TType.STOP:
6284 
        break
6285 
      if fid == 0:
6286 
        if ftype == TType.BOOL:
6287 
          self.success = iprot.readBool();
6288 
        else:
6289 
          iprot.skip(ftype)
6290 
      elif fid == 1:
6291 
        if ftype == TType.STRUCT:
6292 
          self.ucx = UserContextException()
6293 
          self.ucx.read(iprot)
6294 
        else:
6295 
          iprot.skip(ftype)
6296 
      else:
6297 
        iprot.skip(ftype)
6298 
      iprot.readFieldEnd()
6299 
    iprot.readStructEnd()
6300 
 
6301 
  def write(self, oprot):
6302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6304 
      return
559 chandransh 6305 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6306 
    if self.success is not None:
94 ashish 6307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6308 
      oprot.writeBool(self.success)
6309 
      oprot.writeFieldEnd()
3431 rajveer 6310 
    if self.ucx is not None:
94 ashish 6311 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6312 
      self.ucx.write(oprot)
6313 
      oprot.writeFieldEnd()
6314 
    oprot.writeFieldStop()
6315 
    oprot.writeStructEnd()
6316 
 
3431 rajveer 6317 
  def validate(self):
6318 
    return
6319 
 
6320 
 
94 ashish 6321 
  def __repr__(self):
6322 
    L = ['%s=%r' % (key, value)
6323 
      for key, value in self.__dict__.iteritems()]
6324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6325 
 
6326 
  def __eq__(self, other):
6327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6328 
 
6329 
  def __ne__(self, other):
6330 
    return not (self == other)
6331 
 
559 chandransh 6332 
class setUserAsLoggedIn_args:
94 ashish 6333 
  """
6334 
  Attributes:
559 chandransh 6335 
   - userId
94 ashish 6336 
   - timestamp
6337 
  """
6338 
 
6339 
  thrift_spec = (
6340 
    None, # 0
559 chandransh 6341 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6342 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6343 
  )
6344 
 
559 chandransh 6345 
  def __init__(self, userId=None, timestamp=None,):
6346 
    self.userId = userId
94 ashish 6347 
    self.timestamp = timestamp
6348 
 
6349 
  def read(self, iprot):
6350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6352 
      return
6353 
    iprot.readStructBegin()
6354 
    while True:
6355 
      (fname, ftype, fid) = iprot.readFieldBegin()
6356 
      if ftype == TType.STOP:
6357 
        break
6358 
      if fid == 1:
559 chandransh 6359 
        if ftype == TType.I64:
6360 
          self.userId = iprot.readI64();
94 ashish 6361 
        else:
6362 
          iprot.skip(ftype)
6363 
      elif fid == 2:
6364 
        if ftype == TType.I64:
6365 
          self.timestamp = iprot.readI64();
6366 
        else:
6367 
          iprot.skip(ftype)
6368 
      else:
6369 
        iprot.skip(ftype)
6370 
      iprot.readFieldEnd()
6371 
    iprot.readStructEnd()
6372 
 
6373 
  def write(self, oprot):
6374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6376 
      return
559 chandransh 6377 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6378 
    if self.userId is not None:
559 chandransh 6379 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6380 
      oprot.writeI64(self.userId)
94 ashish 6381 
      oprot.writeFieldEnd()
3431 rajveer 6382 
    if self.timestamp is not None:
94 ashish 6383 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6384 
      oprot.writeI64(self.timestamp)
6385 
      oprot.writeFieldEnd()
6386 
    oprot.writeFieldStop()
6387 
    oprot.writeStructEnd()
6388 
 
3431 rajveer 6389 
  def validate(self):
6390 
    return
6391 
 
6392 
 
94 ashish 6393 
  def __repr__(self):
6394 
    L = ['%s=%r' % (key, value)
6395 
      for key, value in self.__dict__.iteritems()]
6396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6397 
 
6398 
  def __eq__(self, other):
6399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6400 
 
6401 
  def __ne__(self, other):
6402 
    return not (self == other)
6403 
 
559 chandransh 6404 
class setUserAsLoggedIn_result:
94 ashish 6405 
  """
6406 
  Attributes:
6407 
   - success
6408 
   - ucx
6409 
  """
6410 
 
6411 
  thrift_spec = (
6412 
    (0, TType.BOOL, 'success', None, None, ), # 0
6413 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6414 
  )
6415 
 
6416 
  def __init__(self, success=None, ucx=None,):
6417 
    self.success = success
6418 
    self.ucx = ucx
6419 
 
6420 
  def read(self, iprot):
6421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6423 
      return
6424 
    iprot.readStructBegin()
6425 
    while True:
6426 
      (fname, ftype, fid) = iprot.readFieldBegin()
6427 
      if ftype == TType.STOP:
6428 
        break
6429 
      if fid == 0:
6430 
        if ftype == TType.BOOL:
6431 
          self.success = iprot.readBool();
6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      elif fid == 1:
6435 
        if ftype == TType.STRUCT:
6436 
          self.ucx = UserContextException()
6437 
          self.ucx.read(iprot)
6438 
        else:
6439 
          iprot.skip(ftype)
6440 
      else:
6441 
        iprot.skip(ftype)
6442 
      iprot.readFieldEnd()
6443 
    iprot.readStructEnd()
6444 
 
6445 
  def write(self, oprot):
6446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6448 
      return
559 chandransh 6449 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6450 
    if self.success is not None:
94 ashish 6451 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6452 
      oprot.writeBool(self.success)
6453 
      oprot.writeFieldEnd()
3431 rajveer 6454 
    if self.ucx is not None:
94 ashish 6455 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6456 
      self.ucx.write(oprot)
6457 
      oprot.writeFieldEnd()
6458 
    oprot.writeFieldStop()
6459 
    oprot.writeStructEnd()
6460 
 
3431 rajveer 6461 
  def validate(self):
6462 
    return
6463 
 
6464 
 
94 ashish 6465 
  def __repr__(self):
6466 
    L = ['%s=%r' % (key, value)
6467 
      for key, value in self.__dict__.iteritems()]
6468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6469 
 
6470 
  def __eq__(self, other):
6471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6472 
 
6473 
  def __ne__(self, other):
6474 
    return not (self == other)
6475 
 
559 chandransh 6476 
class setUserAsLoggedOut_args:
94 ashish 6477 
  """
6478 
  Attributes:
6479 
   - userid
6480 
   - timestamp
6481 
  """
6482 
 
6483 
  thrift_spec = (
6484 
    None, # 0
559 chandransh 6485 
    (1, TType.I64, 'userid', None, None, ), # 1
6486 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6487 
  )
6488 
 
559 chandransh 6489 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6490 
    self.userid = userid
6491 
    self.timestamp = timestamp
6492 
 
6493 
  def read(self, iprot):
6494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6496 
      return
6497 
    iprot.readStructBegin()
6498 
    while True:
6499 
      (fname, ftype, fid) = iprot.readFieldBegin()
6500 
      if ftype == TType.STOP:
6501 
        break
6502 
      if fid == 1:
6503 
        if ftype == TType.I64:
6504 
          self.userid = iprot.readI64();
6505 
        else:
6506 
          iprot.skip(ftype)
559 chandransh 6507 
      elif fid == 2:
94 ashish 6508 
        if ftype == TType.I64:
6509 
          self.timestamp = iprot.readI64();
6510 
        else:
6511 
          iprot.skip(ftype)
6512 
      else:
6513 
        iprot.skip(ftype)
6514 
      iprot.readFieldEnd()
6515 
    iprot.readStructEnd()
6516 
 
6517 
  def write(self, oprot):
6518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6520 
      return
559 chandransh 6521 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6522 
    if self.userid is not None:
559 chandransh 6523 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6524 
      oprot.writeI64(self.userid)
6525 
      oprot.writeFieldEnd()
3431 rajveer 6526 
    if self.timestamp is not None:
559 chandransh 6527 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6528 
      oprot.writeI64(self.timestamp)
6529 
      oprot.writeFieldEnd()
6530 
    oprot.writeFieldStop()
6531 
    oprot.writeStructEnd()
6532 
 
3431 rajveer 6533 
  def validate(self):
6534 
    return
6535 
 
6536 
 
94 ashish 6537 
  def __repr__(self):
6538 
    L = ['%s=%r' % (key, value)
6539 
      for key, value in self.__dict__.iteritems()]
6540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6541 
 
6542 
  def __eq__(self, other):
6543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6544 
 
6545 
  def __ne__(self, other):
6546 
    return not (self == other)
6547 
 
559 chandransh 6548 
class setUserAsLoggedOut_result:
94 ashish 6549 
  """
6550 
  Attributes:
6551 
   - success
6552 
   - ucx
6553 
  """
6554 
 
6555 
  thrift_spec = (
6556 
    (0, TType.BOOL, 'success', None, None, ), # 0
6557 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6558 
  )
6559 
 
6560 
  def __init__(self, success=None, ucx=None,):
6561 
    self.success = success
6562 
    self.ucx = ucx
6563 
 
6564 
  def read(self, iprot):
6565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6567 
      return
6568 
    iprot.readStructBegin()
6569 
    while True:
6570 
      (fname, ftype, fid) = iprot.readFieldBegin()
6571 
      if ftype == TType.STOP:
6572 
        break
6573 
      if fid == 0:
6574 
        if ftype == TType.BOOL:
6575 
          self.success = iprot.readBool();
6576 
        else:
6577 
          iprot.skip(ftype)
6578 
      elif fid == 1:
6579 
        if ftype == TType.STRUCT:
6580 
          self.ucx = UserContextException()
6581 
          self.ucx.read(iprot)
6582 
        else:
6583 
          iprot.skip(ftype)
6584 
      else:
6585 
        iprot.skip(ftype)
6586 
      iprot.readFieldEnd()
6587 
    iprot.readStructEnd()
6588 
 
6589 
  def write(self, oprot):
6590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6592 
      return
559 chandransh 6593 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6594 
    if self.success is not None:
94 ashish 6595 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6596 
      oprot.writeBool(self.success)
6597 
      oprot.writeFieldEnd()
3431 rajveer 6598 
    if self.ucx is not None:
94 ashish 6599 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6600 
      self.ucx.write(oprot)
6601 
      oprot.writeFieldEnd()
6602 
    oprot.writeFieldStop()
6603 
    oprot.writeStructEnd()
6604 
 
3431 rajveer 6605 
  def validate(self):
6606 
    return
6607 
 
6608 
 
94 ashish 6609 
  def __repr__(self):
6610 
    L = ['%s=%r' % (key, value)
6611 
      for key, value in self.__dict__.iteritems()]
6612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6613 
 
6614 
  def __eq__(self, other):
6615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6616 
 
6617 
  def __ne__(self, other):
6618 
    return not (self == other)
6619 
 
559 chandransh 6620 
class setDefaultAddress_args:
94 ashish 6621 
  """
6622 
  Attributes:
6623 
   - userid
6624 
   - addressId
6625 
  """
6626 
 
6627 
  thrift_spec = (
6628 
    None, # 0
6629 
    (1, TType.I64, 'userid', None, None, ), # 1
6630 
    (2, TType.I64, 'addressId', None, None, ), # 2
6631 
  )
6632 
 
6633 
  def __init__(self, userid=None, addressId=None,):
6634 
    self.userid = userid
6635 
    self.addressId = addressId
6636 
 
6637 
  def read(self, iprot):
6638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6640 
      return
6641 
    iprot.readStructBegin()
6642 
    while True:
6643 
      (fname, ftype, fid) = iprot.readFieldBegin()
6644 
      if ftype == TType.STOP:
6645 
        break
6646 
      if fid == 1:
6647 
        if ftype == TType.I64:
6648 
          self.userid = iprot.readI64();
6649 
        else:
6650 
          iprot.skip(ftype)
6651 
      elif fid == 2:
6652 
        if ftype == TType.I64:
6653 
          self.addressId = iprot.readI64();
6654 
        else:
6655 
          iprot.skip(ftype)
6656 
      else:
6657 
        iprot.skip(ftype)
6658 
      iprot.readFieldEnd()
6659 
    iprot.readStructEnd()
6660 
 
6661 
  def write(self, oprot):
6662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6664 
      return
559 chandransh 6665 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6666 
    if self.userid is not None:
94 ashish 6667 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6668 
      oprot.writeI64(self.userid)
6669 
      oprot.writeFieldEnd()
3431 rajveer 6670 
    if self.addressId is not None:
94 ashish 6671 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6672 
      oprot.writeI64(self.addressId)
6673 
      oprot.writeFieldEnd()
6674 
    oprot.writeFieldStop()
6675 
    oprot.writeStructEnd()
6676 
 
3431 rajveer 6677 
  def validate(self):
6678 
    return
6679 
 
6680 
 
94 ashish 6681 
  def __repr__(self):
6682 
    L = ['%s=%r' % (key, value)
6683 
      for key, value in self.__dict__.iteritems()]
6684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6685 
 
6686 
  def __eq__(self, other):
6687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6688 
 
6689 
  def __ne__(self, other):
6690 
    return not (self == other)
6691 
 
559 chandransh 6692 
class setDefaultAddress_result:
94 ashish 6693 
  """
6694 
  Attributes:
6695 
   - success
6696 
   - ucx
6697 
  """
6698 
 
6699 
  thrift_spec = (
6700 
    (0, TType.BOOL, 'success', None, None, ), # 0
6701 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6702 
  )
6703 
 
6704 
  def __init__(self, success=None, ucx=None,):
6705 
    self.success = success
6706 
    self.ucx = ucx
6707 
 
6708 
  def read(self, iprot):
6709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6711 
      return
6712 
    iprot.readStructBegin()
6713 
    while True:
6714 
      (fname, ftype, fid) = iprot.readFieldBegin()
6715 
      if ftype == TType.STOP:
6716 
        break
6717 
      if fid == 0:
6718 
        if ftype == TType.BOOL:
6719 
          self.success = iprot.readBool();
6720 
        else:
6721 
          iprot.skip(ftype)
6722 
      elif fid == 1:
6723 
        if ftype == TType.STRUCT:
6724 
          self.ucx = UserContextException()
6725 
          self.ucx.read(iprot)
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
559 chandransh 6737 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 6738 
    if self.success is not None:
94 ashish 6739 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6740 
      oprot.writeBool(self.success)
6741 
      oprot.writeFieldEnd()
3431 rajveer 6742 
    if self.ucx is not None:
94 ashish 6743 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6744 
      self.ucx.write(oprot)
6745 
      oprot.writeFieldEnd()
6746 
    oprot.writeFieldStop()
6747 
    oprot.writeStructEnd()
6748 
 
3431 rajveer 6749 
  def validate(self):
6750 
    return
6751 
 
6752 
 
94 ashish 6753 
  def __repr__(self):
6754 
    L = ['%s=%r' % (key, value)
6755 
      for key, value in self.__dict__.iteritems()]
6756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6757 
 
6758 
  def __eq__(self, other):
6759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6760 
 
6761 
  def __ne__(self, other):
6762 
    return not (self == other)
6763 
 
559 chandransh 6764 
class updatePassword_args:
94 ashish 6765 
  """
6766 
  Attributes:
559 chandransh 6767 
   - userid
594 rajveer 6768 
   - oldPassword
6769 
   - newPassword
94 ashish 6770 
  """
6771 
 
6772 
  thrift_spec = (
6773 
    None, # 0
559 chandransh 6774 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 6775 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
6776 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 6777 
  )
6778 
 
594 rajveer 6779 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 6780 
    self.userid = userid
594 rajveer 6781 
    self.oldPassword = oldPassword
6782 
    self.newPassword = newPassword
94 ashish 6783 
 
6784 
  def read(self, iprot):
6785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6787 
      return
6788 
    iprot.readStructBegin()
6789 
    while True:
6790 
      (fname, ftype, fid) = iprot.readFieldBegin()
6791 
      if ftype == TType.STOP:
6792 
        break
6793 
      if fid == 1:
6794 
        if ftype == TType.I64:
559 chandransh 6795 
          self.userid = iprot.readI64();
94 ashish 6796 
        else:
6797 
          iprot.skip(ftype)
6798 
      elif fid == 2:
559 chandransh 6799 
        if ftype == TType.STRING:
594 rajveer 6800 
          self.oldPassword = iprot.readString();
94 ashish 6801 
        else:
6802 
          iprot.skip(ftype)
594 rajveer 6803 
      elif fid == 3:
6804 
        if ftype == TType.STRING:
6805 
          self.newPassword = iprot.readString();
6806 
        else:
6807 
          iprot.skip(ftype)
94 ashish 6808 
      else:
6809 
        iprot.skip(ftype)
6810 
      iprot.readFieldEnd()
6811 
    iprot.readStructEnd()
6812 
 
6813 
  def write(self, oprot):
6814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6816 
      return
559 chandransh 6817 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 6818 
    if self.userid is not None:
559 chandransh 6819 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6820 
      oprot.writeI64(self.userid)
94 ashish 6821 
      oprot.writeFieldEnd()
3431 rajveer 6822 
    if self.oldPassword is not None:
594 rajveer 6823 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
6824 
      oprot.writeString(self.oldPassword)
94 ashish 6825 
      oprot.writeFieldEnd()
3431 rajveer 6826 
    if self.newPassword is not None:
594 rajveer 6827 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
6828 
      oprot.writeString(self.newPassword)
6829 
      oprot.writeFieldEnd()
94 ashish 6830 
    oprot.writeFieldStop()
6831 
    oprot.writeStructEnd()
6832 
 
3431 rajveer 6833 
  def validate(self):
6834 
    return
6835 
 
6836 
 
94 ashish 6837 
  def __repr__(self):
6838 
    L = ['%s=%r' % (key, value)
6839 
      for key, value in self.__dict__.iteritems()]
6840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6841 
 
6842 
  def __eq__(self, other):
6843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6844 
 
6845 
  def __ne__(self, other):
6846 
    return not (self == other)
6847 
 
559 chandransh 6848 
class updatePassword_result:
94 ashish 6849 
  """
6850 
  Attributes:
6851 
   - success
6852 
   - ucx
6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    (0, TType.BOOL, 'success', None, None, ), # 0
6857 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6858 
  )
6859 
 
6860 
  def __init__(self, success=None, ucx=None,):
6861 
    self.success = success
6862 
    self.ucx = ucx
6863 
 
6864 
  def read(self, iprot):
6865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6867 
      return
6868 
    iprot.readStructBegin()
6869 
    while True:
6870 
      (fname, ftype, fid) = iprot.readFieldBegin()
6871 
      if ftype == TType.STOP:
6872 
        break
6873 
      if fid == 0:
6874 
        if ftype == TType.BOOL:
6875 
          self.success = iprot.readBool();
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      elif fid == 1:
6879 
        if ftype == TType.STRUCT:
6880 
          self.ucx = UserContextException()
6881 
          self.ucx.read(iprot)
6882 
        else:
6883 
          iprot.skip(ftype)
6884 
      else:
6885 
        iprot.skip(ftype)
6886 
      iprot.readFieldEnd()
6887 
    iprot.readStructEnd()
6888 
 
6889 
  def write(self, oprot):
6890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6892 
      return
559 chandransh 6893 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 6894 
    if self.success is not None:
94 ashish 6895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6896 
      oprot.writeBool(self.success)
6897 
      oprot.writeFieldEnd()
3431 rajveer 6898 
    if self.ucx is not None:
94 ashish 6899 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6900 
      self.ucx.write(oprot)
6901 
      oprot.writeFieldEnd()
6902 
    oprot.writeFieldStop()
6903 
    oprot.writeStructEnd()
6904 
 
3431 rajveer 6905 
  def validate(self):
6906 
    return
6907 
 
6908 
 
94 ashish 6909 
  def __repr__(self):
6910 
    L = ['%s=%r' % (key, value)
6911 
      for key, value in self.__dict__.iteritems()]
6912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6913 
 
6914 
  def __eq__(self, other):
6915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6916 
 
6917 
  def __ne__(self, other):
6918 
    return not (self == other)
6919 
 
581 rajveer 6920 
class forgotPassword_args:
6921 
  """
6922 
  Attributes:
6923 
   - email
884 rajveer 6924 
   - newPassword
581 rajveer 6925 
  """
6926 
 
6927 
  thrift_spec = (
6928 
    None, # 0
6929 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6930 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6931 
  )
6932 
 
884 rajveer 6933 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6934 
    self.email = email
884 rajveer 6935 
    self.newPassword = newPassword
581 rajveer 6936 
 
6937 
  def read(self, iprot):
6938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6940 
      return
6941 
    iprot.readStructBegin()
6942 
    while True:
6943 
      (fname, ftype, fid) = iprot.readFieldBegin()
6944 
      if ftype == TType.STOP:
6945 
        break
6946 
      if fid == 1:
6947 
        if ftype == TType.STRING:
6948 
          self.email = iprot.readString();
6949 
        else:
6950 
          iprot.skip(ftype)
884 rajveer 6951 
      elif fid == 2:
6952 
        if ftype == TType.STRING:
6953 
          self.newPassword = iprot.readString();
6954 
        else:
6955 
          iprot.skip(ftype)
581 rajveer 6956 
      else:
6957 
        iprot.skip(ftype)
6958 
      iprot.readFieldEnd()
6959 
    iprot.readStructEnd()
6960 
 
6961 
  def write(self, oprot):
6962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6964 
      return
6965 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 6966 
    if self.email is not None:
581 rajveer 6967 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6968 
      oprot.writeString(self.email)
6969 
      oprot.writeFieldEnd()
3431 rajveer 6970 
    if self.newPassword is not None:
884 rajveer 6971 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6972 
      oprot.writeString(self.newPassword)
6973 
      oprot.writeFieldEnd()
581 rajveer 6974 
    oprot.writeFieldStop()
6975 
    oprot.writeStructEnd()
6976 
 
3431 rajveer 6977 
  def validate(self):
6978 
    return
6979 
 
6980 
 
581 rajveer 6981 
  def __repr__(self):
6982 
    L = ['%s=%r' % (key, value)
6983 
      for key, value in self.__dict__.iteritems()]
6984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6985 
 
6986 
  def __eq__(self, other):
6987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6988 
 
6989 
  def __ne__(self, other):
6990 
    return not (self == other)
6991 
 
6992 
class forgotPassword_result:
6993 
  """
6994 
  Attributes:
6995 
   - success
6996 
   - ucx
6997 
  """
6998 
 
6999 
  thrift_spec = (
7000 
    (0, TType.BOOL, 'success', None, None, ), # 0
7001 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7002 
  )
7003 
 
7004 
  def __init__(self, success=None, ucx=None,):
7005 
    self.success = success
7006 
    self.ucx = ucx
7007 
 
7008 
  def read(self, iprot):
7009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7011 
      return
7012 
    iprot.readStructBegin()
7013 
    while True:
7014 
      (fname, ftype, fid) = iprot.readFieldBegin()
7015 
      if ftype == TType.STOP:
7016 
        break
7017 
      if fid == 0:
7018 
        if ftype == TType.BOOL:
7019 
          self.success = iprot.readBool();
7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      elif fid == 1:
7023 
        if ftype == TType.STRUCT:
7024 
          self.ucx = UserContextException()
7025 
          self.ucx.read(iprot)
7026 
        else:
7027 
          iprot.skip(ftype)
7028 
      else:
7029 
        iprot.skip(ftype)
7030 
      iprot.readFieldEnd()
7031 
    iprot.readStructEnd()
7032 
 
7033 
  def write(self, oprot):
7034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7036 
      return
7037 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7038 
    if self.success is not None:
581 rajveer 7039 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7040 
      oprot.writeBool(self.success)
7041 
      oprot.writeFieldEnd()
3431 rajveer 7042 
    if self.ucx is not None:
581 rajveer 7043 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7044 
      self.ucx.write(oprot)
7045 
      oprot.writeFieldEnd()
7046 
    oprot.writeFieldStop()
7047 
    oprot.writeStructEnd()
7048 
 
3431 rajveer 7049 
  def validate(self):
7050 
    return
7051 
 
7052 
 
581 rajveer 7053 
  def __repr__(self):
7054 
    L = ['%s=%r' % (key, value)
7055 
      for key, value in self.__dict__.iteritems()]
7056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7057 
 
7058 
  def __eq__(self, other):
7059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7060 
 
7061 
  def __ne__(self, other):
7062 
    return not (self == other)
7063 
 
594 rajveer 7064 
class getAllAddressesForUser_args:
7065 
  """
7066 
  Attributes:
7067 
   - userId
7068 
  """
7069 
 
7070 
  thrift_spec = (
7071 
    None, # 0
7072 
    (1, TType.I64, 'userId', None, None, ), # 1
7073 
  )
7074 
 
7075 
  def __init__(self, userId=None,):
7076 
    self.userId = userId
7077 
 
7078 
  def read(self, iprot):
7079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7081 
      return
7082 
    iprot.readStructBegin()
7083 
    while True:
7084 
      (fname, ftype, fid) = iprot.readFieldBegin()
7085 
      if ftype == TType.STOP:
7086 
        break
7087 
      if fid == 1:
7088 
        if ftype == TType.I64:
7089 
          self.userId = iprot.readI64();
7090 
        else:
7091 
          iprot.skip(ftype)
7092 
      else:
7093 
        iprot.skip(ftype)
7094 
      iprot.readFieldEnd()
7095 
    iprot.readStructEnd()
7096 
 
7097 
  def write(self, oprot):
7098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7100 
      return
7101 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7102 
    if self.userId is not None:
594 rajveer 7103 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7104 
      oprot.writeI64(self.userId)
7105 
      oprot.writeFieldEnd()
7106 
    oprot.writeFieldStop()
7107 
    oprot.writeStructEnd()
7108 
 
3431 rajveer 7109 
  def validate(self):
7110 
    return
7111 
 
7112 
 
594 rajveer 7113 
  def __repr__(self):
7114 
    L = ['%s=%r' % (key, value)
7115 
      for key, value in self.__dict__.iteritems()]
7116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7117 
 
7118 
  def __eq__(self, other):
7119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7120 
 
7121 
  def __ne__(self, other):
7122 
    return not (self == other)
7123 
 
7124 
class getAllAddressesForUser_result:
7125 
  """
7126 
  Attributes:
7127 
   - success
7128 
   - ucx
7129 
  """
7130 
 
7131 
  thrift_spec = (
7132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7133 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7134 
  )
7135 
 
7136 
  def __init__(self, success=None, ucx=None,):
7137 
    self.success = success
7138 
    self.ucx = ucx
7139 
 
7140 
  def read(self, iprot):
7141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7143 
      return
7144 
    iprot.readStructBegin()
7145 
    while True:
7146 
      (fname, ftype, fid) = iprot.readFieldBegin()
7147 
      if ftype == TType.STOP:
7148 
        break
7149 
      if fid == 0:
7150 
        if ftype == TType.LIST:
7151 
          self.success = []
11592 amit.gupta 7152 
          (_etype100, _size97) = iprot.readListBegin()
7153 
          for _i101 in xrange(_size97):
7154 
            _elem102 = Address()
7155 
            _elem102.read(iprot)
7156 
            self.success.append(_elem102)
594 rajveer 7157 
          iprot.readListEnd()
7158 
        else:
7159 
          iprot.skip(ftype)
7160 
      elif fid == 1:
7161 
        if ftype == TType.STRUCT:
7162 
          self.ucx = UserContextException()
7163 
          self.ucx.read(iprot)
7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      else:
7167 
        iprot.skip(ftype)
7168 
      iprot.readFieldEnd()
7169 
    iprot.readStructEnd()
7170 
 
7171 
  def write(self, oprot):
7172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7174 
      return
7175 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7176 
    if self.success is not None:
594 rajveer 7177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7179 
      for iter103 in self.success:
7180 
        iter103.write(oprot)
594 rajveer 7181 
      oprot.writeListEnd()
7182 
      oprot.writeFieldEnd()
3431 rajveer 7183 
    if self.ucx is not None:
594 rajveer 7184 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7185 
      self.ucx.write(oprot)
7186 
      oprot.writeFieldEnd()
7187 
    oprot.writeFieldStop()
7188 
    oprot.writeStructEnd()
7189 
 
3431 rajveer 7190 
  def validate(self):
7191 
    return
7192 
 
7193 
 
594 rajveer 7194 
  def __repr__(self):
7195 
    L = ['%s=%r' % (key, value)
7196 
      for key, value in self.__dict__.iteritems()]
7197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7198 
 
7199 
  def __eq__(self, other):
7200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7201 
 
7202 
  def __ne__(self, other):
7203 
    return not (self == other)
7204 
 
1894 vikas 7205 
class getAddressById_args:
7206 
  """
7207 
  Attributes:
7208 
   - addressId
7209 
  """
7210 
 
7211 
  thrift_spec = (
7212 
    None, # 0
7213 
    (1, TType.I64, 'addressId', None, None, ), # 1
7214 
  )
7215 
 
7216 
  def __init__(self, addressId=None,):
7217 
    self.addressId = addressId
7218 
 
7219 
  def read(self, iprot):
7220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7222 
      return
7223 
    iprot.readStructBegin()
7224 
    while True:
7225 
      (fname, ftype, fid) = iprot.readFieldBegin()
7226 
      if ftype == TType.STOP:
7227 
        break
7228 
      if fid == 1:
7229 
        if ftype == TType.I64:
7230 
          self.addressId = iprot.readI64();
7231 
        else:
7232 
          iprot.skip(ftype)
7233 
      else:
7234 
        iprot.skip(ftype)
7235 
      iprot.readFieldEnd()
7236 
    iprot.readStructEnd()
7237 
 
7238 
  def write(self, oprot):
7239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7241 
      return
7242 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7243 
    if self.addressId is not None:
1894 vikas 7244 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7245 
      oprot.writeI64(self.addressId)
7246 
      oprot.writeFieldEnd()
7247 
    oprot.writeFieldStop()
7248 
    oprot.writeStructEnd()
7249 
 
3431 rajveer 7250 
  def validate(self):
7251 
    return
7252 
 
7253 
 
1894 vikas 7254 
  def __repr__(self):
7255 
    L = ['%s=%r' % (key, value)
7256 
      for key, value in self.__dict__.iteritems()]
7257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7258 
 
7259 
  def __eq__(self, other):
7260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7261 
 
7262 
  def __ne__(self, other):
7263 
    return not (self == other)
7264 
 
7265 
class getAddressById_result:
7266 
  """
7267 
  Attributes:
7268 
   - success
7269 
   - ucx
7270 
  """
7271 
 
7272 
  thrift_spec = (
7273 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7274 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7275 
  )
7276 
 
7277 
  def __init__(self, success=None, ucx=None,):
7278 
    self.success = success
7279 
    self.ucx = ucx
7280 
 
7281 
  def read(self, iprot):
7282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7284 
      return
7285 
    iprot.readStructBegin()
7286 
    while True:
7287 
      (fname, ftype, fid) = iprot.readFieldBegin()
7288 
      if ftype == TType.STOP:
7289 
        break
7290 
      if fid == 0:
7291 
        if ftype == TType.STRUCT:
7292 
          self.success = Address()
7293 
          self.success.read(iprot)
7294 
        else:
7295 
          iprot.skip(ftype)
7296 
      elif fid == 1:
7297 
        if ftype == TType.STRUCT:
7298 
          self.ucx = UserContextException()
7299 
          self.ucx.read(iprot)
7300 
        else:
7301 
          iprot.skip(ftype)
7302 
      else:
7303 
        iprot.skip(ftype)
7304 
      iprot.readFieldEnd()
7305 
    iprot.readStructEnd()
7306 
 
7307 
  def write(self, oprot):
7308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7310 
      return
7311 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7312 
    if self.success is not None:
1894 vikas 7313 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7314 
      self.success.write(oprot)
7315 
      oprot.writeFieldEnd()
3431 rajveer 7316 
    if self.ucx is not None:
1894 vikas 7317 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7318 
      self.ucx.write(oprot)
7319 
      oprot.writeFieldEnd()
7320 
    oprot.writeFieldStop()
7321 
    oprot.writeStructEnd()
7322 
 
3431 rajveer 7323 
  def validate(self):
7324 
    return
7325 
 
7326 
 
1894 vikas 7327 
  def __repr__(self):
7328 
    L = ['%s=%r' % (key, value)
7329 
      for key, value in self.__dict__.iteritems()]
7330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7331 
 
7332 
  def __eq__(self, other):
7333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7334 
 
7335 
  def __ne__(self, other):
7336 
    return not (self == other)
7337 
 
594 rajveer 7338 
class getDefaultAddressId_args:
7339 
  """
7340 
  Attributes:
7341 
   - userId
7342 
  """
7343 
 
7344 
  thrift_spec = (
7345 
    None, # 0
7346 
    (1, TType.I64, 'userId', None, None, ), # 1
7347 
  )
7348 
 
7349 
  def __init__(self, userId=None,):
7350 
    self.userId = userId
7351 
 
7352 
  def read(self, iprot):
7353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7355 
      return
7356 
    iprot.readStructBegin()
7357 
    while True:
7358 
      (fname, ftype, fid) = iprot.readFieldBegin()
7359 
      if ftype == TType.STOP:
7360 
        break
7361 
      if fid == 1:
7362 
        if ftype == TType.I64:
7363 
          self.userId = iprot.readI64();
7364 
        else:
7365 
          iprot.skip(ftype)
7366 
      else:
7367 
        iprot.skip(ftype)
7368 
      iprot.readFieldEnd()
7369 
    iprot.readStructEnd()
7370 
 
7371 
  def write(self, oprot):
7372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7374 
      return
7375 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7376 
    if self.userId is not None:
594 rajveer 7377 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7378 
      oprot.writeI64(self.userId)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
3431 rajveer 7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
594 rajveer 7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class getDefaultAddressId_result:
7399 
  """
7400 
  Attributes:
7401 
   - success
7402 
   - ucx
7403 
  """
7404 
 
7405 
  thrift_spec = (
7406 
    (0, TType.I64, 'success', None, None, ), # 0
7407 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7408 
  )
7409 
 
7410 
  def __init__(self, success=None, ucx=None,):
7411 
    self.success = success
7412 
    self.ucx = ucx
7413 
 
7414 
  def read(self, iprot):
7415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7417 
      return
7418 
    iprot.readStructBegin()
7419 
    while True:
7420 
      (fname, ftype, fid) = iprot.readFieldBegin()
7421 
      if ftype == TType.STOP:
7422 
        break
7423 
      if fid == 0:
7424 
        if ftype == TType.I64:
7425 
          self.success = iprot.readI64();
7426 
        else:
7427 
          iprot.skip(ftype)
7428 
      elif fid == 1:
7429 
        if ftype == TType.STRUCT:
7430 
          self.ucx = UserContextException()
7431 
          self.ucx.read(iprot)
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7444 
    if self.success is not None:
594 rajveer 7445 
      oprot.writeFieldBegin('success', TType.I64, 0)
7446 
      oprot.writeI64(self.success)
7447 
      oprot.writeFieldEnd()
3431 rajveer 7448 
    if self.ucx is not None:
594 rajveer 7449 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7450 
      self.ucx.write(oprot)
7451 
      oprot.writeFieldEnd()
7452 
    oprot.writeFieldStop()
7453 
    oprot.writeStructEnd()
7454 
 
3431 rajveer 7455 
  def validate(self):
7456 
    return
7457 
 
7458 
 
594 rajveer 7459 
  def __repr__(self):
7460 
    L = ['%s=%r' % (key, value)
7461 
      for key, value in self.__dict__.iteritems()]
7462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7463 
 
7464 
  def __eq__(self, other):
7465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7466 
 
7467 
  def __ne__(self, other):
7468 
    return not (self == other)
7469 
 
785 rajveer 7470 
class getDefaultPincode_args:
7471 
  """
7472 
  Attributes:
7473 
   - userId
7474 
  """
7475 
 
7476 
  thrift_spec = (
7477 
    None, # 0
7478 
    (1, TType.I64, 'userId', None, None, ), # 1
7479 
  )
7480 
 
7481 
  def __init__(self, userId=None,):
7482 
    self.userId = userId
7483 
 
7484 
  def read(self, iprot):
7485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7487 
      return
7488 
    iprot.readStructBegin()
7489 
    while True:
7490 
      (fname, ftype, fid) = iprot.readFieldBegin()
7491 
      if ftype == TType.STOP:
7492 
        break
7493 
      if fid == 1:
7494 
        if ftype == TType.I64:
7495 
          self.userId = iprot.readI64();
7496 
        else:
7497 
          iprot.skip(ftype)
7498 
      else:
7499 
        iprot.skip(ftype)
7500 
      iprot.readFieldEnd()
7501 
    iprot.readStructEnd()
7502 
 
7503 
  def write(self, oprot):
7504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7506 
      return
7507 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7508 
    if self.userId is not None:
785 rajveer 7509 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7510 
      oprot.writeI64(self.userId)
7511 
      oprot.writeFieldEnd()
7512 
    oprot.writeFieldStop()
7513 
    oprot.writeStructEnd()
7514 
 
3431 rajveer 7515 
  def validate(self):
7516 
    return
7517 
 
7518 
 
785 rajveer 7519 
  def __repr__(self):
7520 
    L = ['%s=%r' % (key, value)
7521 
      for key, value in self.__dict__.iteritems()]
7522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7523 
 
7524 
  def __eq__(self, other):
7525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7526 
 
7527 
  def __ne__(self, other):
7528 
    return not (self == other)
7529 
 
7530 
class getDefaultPincode_result:
7531 
  """
7532 
  Attributes:
7533 
   - success
7534 
   - ucx
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    (0, TType.STRING, 'success', None, None, ), # 0
7539 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, success=None, ucx=None,):
7543 
    self.success = success
7544 
    self.ucx = ucx
7545 
 
7546 
  def read(self, iprot):
7547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7549 
      return
7550 
    iprot.readStructBegin()
7551 
    while True:
7552 
      (fname, ftype, fid) = iprot.readFieldBegin()
7553 
      if ftype == TType.STOP:
7554 
        break
7555 
      if fid == 0:
7556 
        if ftype == TType.STRING:
7557 
          self.success = iprot.readString();
7558 
        else:
7559 
          iprot.skip(ftype)
7560 
      elif fid == 1:
7561 
        if ftype == TType.STRUCT:
7562 
          self.ucx = UserContextException()
7563 
          self.ucx.read(iprot)
7564 
        else:
7565 
          iprot.skip(ftype)
7566 
      else:
7567 
        iprot.skip(ftype)
7568 
      iprot.readFieldEnd()
7569 
    iprot.readStructEnd()
7570 
 
7571 
  def write(self, oprot):
7572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7574 
      return
7575 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7576 
    if self.success is not None:
785 rajveer 7577 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7578 
      oprot.writeString(self.success)
7579 
      oprot.writeFieldEnd()
3431 rajveer 7580 
    if self.ucx is not None:
785 rajveer 7581 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7582 
      self.ucx.write(oprot)
7583 
      oprot.writeFieldEnd()
7584 
    oprot.writeFieldStop()
7585 
    oprot.writeStructEnd()
7586 
 
3431 rajveer 7587 
  def validate(self):
7588 
    return
7589 
 
7590 
 
785 rajveer 7591 
  def __repr__(self):
7592 
    L = ['%s=%r' % (key, value)
7593 
      for key, value in self.__dict__.iteritems()]
7594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7595 
 
7596 
  def __eq__(self, other):
7597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7598 
 
7599 
  def __ne__(self, other):
7600 
    return not (self == other)
7601 
 
1274 varun.gupt 7602 
class saveUserCommunication_args:
7603 
  """
7604 
  Attributes:
7605 
   - userId
7606 
   - replyTo
7607 
   - communicationType
7608 
   - orderId
7609 
   - airwaybillNo
7610 
   - productName
7611 
   - subject
7612 
   - message
7613 
  """
7614 
 
7615 
  thrift_spec = (
7616 
    None, # 0
7617 
    (1, TType.I64, 'userId', None, None, ), # 1
7618 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7619 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7620 
    (4, TType.I64, 'orderId', None, None, ), # 4
7621 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7622 
    (6, TType.STRING, 'productName', None, None, ), # 6
7623 
    (7, TType.STRING, 'subject', None, None, ), # 7
7624 
    (8, TType.STRING, 'message', None, None, ), # 8
7625 
  )
7626 
 
7627 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7628 
    self.userId = userId
7629 
    self.replyTo = replyTo
7630 
    self.communicationType = communicationType
7631 
    self.orderId = orderId
7632 
    self.airwaybillNo = airwaybillNo
7633 
    self.productName = productName
7634 
    self.subject = subject
7635 
    self.message = message
7636 
 
7637 
  def read(self, iprot):
7638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7640 
      return
7641 
    iprot.readStructBegin()
7642 
    while True:
7643 
      (fname, ftype, fid) = iprot.readFieldBegin()
7644 
      if ftype == TType.STOP:
7645 
        break
7646 
      if fid == 1:
7647 
        if ftype == TType.I64:
7648 
          self.userId = iprot.readI64();
7649 
        else:
7650 
          iprot.skip(ftype)
7651 
      elif fid == 2:
7652 
        if ftype == TType.STRING:
7653 
          self.replyTo = iprot.readString();
7654 
        else:
7655 
          iprot.skip(ftype)
7656 
      elif fid == 3:
7657 
        if ftype == TType.I64:
7658 
          self.communicationType = iprot.readI64();
7659 
        else:
7660 
          iprot.skip(ftype)
7661 
      elif fid == 4:
7662 
        if ftype == TType.I64:
7663 
          self.orderId = iprot.readI64();
7664 
        else:
7665 
          iprot.skip(ftype)
7666 
      elif fid == 5:
7667 
        if ftype == TType.STRING:
7668 
          self.airwaybillNo = iprot.readString();
7669 
        else:
7670 
          iprot.skip(ftype)
7671 
      elif fid == 6:
7672 
        if ftype == TType.STRING:
7673 
          self.productName = iprot.readString();
7674 
        else:
7675 
          iprot.skip(ftype)
7676 
      elif fid == 7:
7677 
        if ftype == TType.STRING:
7678 
          self.subject = iprot.readString();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      elif fid == 8:
7682 
        if ftype == TType.STRING:
7683 
          self.message = iprot.readString();
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      else:
7687 
        iprot.skip(ftype)
7688 
      iprot.readFieldEnd()
7689 
    iprot.readStructEnd()
7690 
 
7691 
  def write(self, oprot):
7692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7694 
      return
7695 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7696 
    if self.userId is not None:
1274 varun.gupt 7697 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7698 
      oprot.writeI64(self.userId)
7699 
      oprot.writeFieldEnd()
3431 rajveer 7700 
    if self.replyTo is not None:
1274 varun.gupt 7701 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7702 
      oprot.writeString(self.replyTo)
7703 
      oprot.writeFieldEnd()
3431 rajveer 7704 
    if self.communicationType is not None:
1274 varun.gupt 7705 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
7706 
      oprot.writeI64(self.communicationType)
7707 
      oprot.writeFieldEnd()
3431 rajveer 7708 
    if self.orderId is not None:
1274 varun.gupt 7709 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7710 
      oprot.writeI64(self.orderId)
7711 
      oprot.writeFieldEnd()
3431 rajveer 7712 
    if self.airwaybillNo is not None:
1274 varun.gupt 7713 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
7714 
      oprot.writeString(self.airwaybillNo)
7715 
      oprot.writeFieldEnd()
3431 rajveer 7716 
    if self.productName is not None:
1274 varun.gupt 7717 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
7718 
      oprot.writeString(self.productName)
7719 
      oprot.writeFieldEnd()
3431 rajveer 7720 
    if self.subject is not None:
1274 varun.gupt 7721 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
7722 
      oprot.writeString(self.subject)
7723 
      oprot.writeFieldEnd()
3431 rajveer 7724 
    if self.message is not None:
1274 varun.gupt 7725 
      oprot.writeFieldBegin('message', TType.STRING, 8)
7726 
      oprot.writeString(self.message)
7727 
      oprot.writeFieldEnd()
7728 
    oprot.writeFieldStop()
7729 
    oprot.writeStructEnd()
7730 
 
3431 rajveer 7731 
  def validate(self):
7732 
    return
7733 
 
7734 
 
1274 varun.gupt 7735 
  def __repr__(self):
7736 
    L = ['%s=%r' % (key, value)
7737 
      for key, value in self.__dict__.iteritems()]
7738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7739 
 
7740 
  def __eq__(self, other):
7741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7742 
 
7743 
  def __ne__(self, other):
7744 
    return not (self == other)
7745 
 
7746 
class saveUserCommunication_result:
7747 
  """
7748 
  Attributes:
7749 
   - success
7750 
   - ucx
7751 
  """
7752 
 
7753 
  thrift_spec = (
7754 
    (0, TType.BOOL, 'success', None, None, ), # 0
7755 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7756 
  )
7757 
 
7758 
  def __init__(self, success=None, ucx=None,):
7759 
    self.success = success
7760 
    self.ucx = ucx
7761 
 
7762 
  def read(self, iprot):
7763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7765 
      return
7766 
    iprot.readStructBegin()
7767 
    while True:
7768 
      (fname, ftype, fid) = iprot.readFieldBegin()
7769 
      if ftype == TType.STOP:
7770 
        break
7771 
      if fid == 0:
7772 
        if ftype == TType.BOOL:
7773 
          self.success = iprot.readBool();
7774 
        else:
7775 
          iprot.skip(ftype)
7776 
      elif fid == 1:
7777 
        if ftype == TType.STRUCT:
7778 
          self.ucx = UserCommunicationException()
7779 
          self.ucx.read(iprot)
7780 
        else:
7781 
          iprot.skip(ftype)
7782 
      else:
7783 
        iprot.skip(ftype)
7784 
      iprot.readFieldEnd()
7785 
    iprot.readStructEnd()
7786 
 
7787 
  def write(self, oprot):
7788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7790 
      return
7791 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 7792 
    if self.success is not None:
1274 varun.gupt 7793 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7794 
      oprot.writeBool(self.success)
7795 
      oprot.writeFieldEnd()
3431 rajveer 7796 
    if self.ucx is not None:
1274 varun.gupt 7797 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7798 
      self.ucx.write(oprot)
7799 
      oprot.writeFieldEnd()
7800 
    oprot.writeFieldStop()
7801 
    oprot.writeStructEnd()
7802 
 
3431 rajveer 7803 
  def validate(self):
7804 
    return
7805 
 
7806 
 
1274 varun.gupt 7807 
  def __repr__(self):
7808 
    L = ['%s=%r' % (key, value)
7809 
      for key, value in self.__dict__.iteritems()]
7810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7811 
 
7812 
  def __eq__(self, other):
7813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7814 
 
7815 
  def __ne__(self, other):
7816 
    return not (self == other)
7817 
 
1590 varun.gupt 7818 
class getUserCommunicationById_args:
7819 
  """
7820 
  Attributes:
7821 
   - id
7822 
  """
7823 
 
7824 
  thrift_spec = (
7825 
    None, # 0
7826 
    (1, TType.I64, 'id', None, None, ), # 1
7827 
  )
7828 
 
7829 
  def __init__(self, id=None,):
7830 
    self.id = id
7831 
 
7832 
  def read(self, iprot):
7833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7835 
      return
7836 
    iprot.readStructBegin()
7837 
    while True:
7838 
      (fname, ftype, fid) = iprot.readFieldBegin()
7839 
      if ftype == TType.STOP:
7840 
        break
7841 
      if fid == 1:
7842 
        if ftype == TType.I64:
7843 
          self.id = iprot.readI64();
7844 
        else:
7845 
          iprot.skip(ftype)
7846 
      else:
7847 
        iprot.skip(ftype)
7848 
      iprot.readFieldEnd()
7849 
    iprot.readStructEnd()
7850 
 
7851 
  def write(self, oprot):
7852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7854 
      return
7855 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 7856 
    if self.id is not None:
1590 varun.gupt 7857 
      oprot.writeFieldBegin('id', TType.I64, 1)
7858 
      oprot.writeI64(self.id)
7859 
      oprot.writeFieldEnd()
7860 
    oprot.writeFieldStop()
7861 
    oprot.writeStructEnd()
7862 
 
3431 rajveer 7863 
  def validate(self):
7864 
    return
7865 
 
7866 
 
1590 varun.gupt 7867 
  def __repr__(self):
7868 
    L = ['%s=%r' % (key, value)
7869 
      for key, value in self.__dict__.iteritems()]
7870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7871 
 
7872 
  def __eq__(self, other):
7873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7874 
 
7875 
  def __ne__(self, other):
7876 
    return not (self == other)
7877 
 
7878 
class getUserCommunicationById_result:
7879 
  """
7880 
  Attributes:
7881 
   - success
7882 
   - ucx
7883 
  """
7884 
 
7885 
  thrift_spec = (
7886 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
7887 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7888 
  )
7889 
 
7890 
  def __init__(self, success=None, ucx=None,):
7891 
    self.success = success
7892 
    self.ucx = ucx
7893 
 
7894 
  def read(self, iprot):
7895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7897 
      return
7898 
    iprot.readStructBegin()
7899 
    while True:
7900 
      (fname, ftype, fid) = iprot.readFieldBegin()
7901 
      if ftype == TType.STOP:
7902 
        break
7903 
      if fid == 0:
7904 
        if ftype == TType.STRUCT:
7905 
          self.success = UserCommunication()
7906 
          self.success.read(iprot)
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      elif fid == 1:
7910 
        if ftype == TType.STRUCT:
7911 
          self.ucx = UserCommunicationException()
7912 
          self.ucx.read(iprot)
7913 
        else:
7914 
          iprot.skip(ftype)
7915 
      else:
7916 
        iprot.skip(ftype)
7917 
      iprot.readFieldEnd()
7918 
    iprot.readStructEnd()
7919 
 
7920 
  def write(self, oprot):
7921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7923 
      return
7924 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 7925 
    if self.success is not None:
1590 varun.gupt 7926 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7927 
      self.success.write(oprot)
7928 
      oprot.writeFieldEnd()
3431 rajveer 7929 
    if self.ucx is not None:
1590 varun.gupt 7930 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7931 
      self.ucx.write(oprot)
7932 
      oprot.writeFieldEnd()
7933 
    oprot.writeFieldStop()
7934 
    oprot.writeStructEnd()
7935 
 
3431 rajveer 7936 
  def validate(self):
7937 
    return
7938 
 
7939 
 
1590 varun.gupt 7940 
  def __repr__(self):
7941 
    L = ['%s=%r' % (key, value)
7942 
      for key, value in self.__dict__.iteritems()]
7943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7944 
 
7945 
  def __eq__(self, other):
7946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7947 
 
7948 
  def __ne__(self, other):
7949 
    return not (self == other)
7950 
 
7951 
class getUserCommunicationByUser_args:
7952 
  """
7953 
  Attributes:
7954 
   - userId
7955 
  """
7956 
 
7957 
  thrift_spec = (
7958 
    None, # 0
7959 
    (1, TType.I64, 'userId', None, None, ), # 1
7960 
  )
7961 
 
7962 
  def __init__(self, userId=None,):
7963 
    self.userId = userId
7964 
 
7965 
  def read(self, iprot):
7966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7968 
      return
7969 
    iprot.readStructBegin()
7970 
    while True:
7971 
      (fname, ftype, fid) = iprot.readFieldBegin()
7972 
      if ftype == TType.STOP:
7973 
        break
7974 
      if fid == 1:
7975 
        if ftype == TType.I64:
7976 
          self.userId = iprot.readI64();
7977 
        else:
7978 
          iprot.skip(ftype)
7979 
      else:
7980 
        iprot.skip(ftype)
7981 
      iprot.readFieldEnd()
7982 
    iprot.readStructEnd()
7983 
 
7984 
  def write(self, oprot):
7985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7987 
      return
7988 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 7989 
    if self.userId is not None:
1590 varun.gupt 7990 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7991 
      oprot.writeI64(self.userId)
7992 
      oprot.writeFieldEnd()
7993 
    oprot.writeFieldStop()
7994 
    oprot.writeStructEnd()
7995 
 
3431 rajveer 7996 
  def validate(self):
7997 
    return
7998 
 
7999 
 
1590 varun.gupt 8000 
  def __repr__(self):
8001 
    L = ['%s=%r' % (key, value)
8002 
      for key, value in self.__dict__.iteritems()]
8003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8004 
 
8005 
  def __eq__(self, other):
8006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8007 
 
8008 
  def __ne__(self, other):
8009 
    return not (self == other)
8010 
 
8011 
class getUserCommunicationByUser_result:
8012 
  """
8013 
  Attributes:
8014 
   - success
8015 
   - ucx
8016 
  """
8017 
 
8018 
  thrift_spec = (
8019 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8020 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8021 
  )
8022 
 
8023 
  def __init__(self, success=None, ucx=None,):
8024 
    self.success = success
8025 
    self.ucx = ucx
8026 
 
8027 
  def read(self, iprot):
8028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8030 
      return
8031 
    iprot.readStructBegin()
8032 
    while True:
8033 
      (fname, ftype, fid) = iprot.readFieldBegin()
8034 
      if ftype == TType.STOP:
8035 
        break
8036 
      if fid == 0:
8037 
        if ftype == TType.LIST:
8038 
          self.success = []
11592 amit.gupta 8039 
          (_etype107, _size104) = iprot.readListBegin()
8040 
          for _i108 in xrange(_size104):
8041 
            _elem109 = UserCommunication()
8042 
            _elem109.read(iprot)
8043 
            self.success.append(_elem109)
1590 varun.gupt 8044 
          iprot.readListEnd()
8045 
        else:
8046 
          iprot.skip(ftype)
8047 
      elif fid == 1:
8048 
        if ftype == TType.STRUCT:
8049 
          self.ucx = UserCommunicationException()
8050 
          self.ucx.read(iprot)
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      else:
8054 
        iprot.skip(ftype)
8055 
      iprot.readFieldEnd()
8056 
    iprot.readStructEnd()
8057 
 
8058 
  def write(self, oprot):
8059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8061 
      return
8062 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8063 
    if self.success is not None:
1590 varun.gupt 8064 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8065 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8066 
      for iter110 in self.success:
8067 
        iter110.write(oprot)
1590 varun.gupt 8068 
      oprot.writeListEnd()
8069 
      oprot.writeFieldEnd()
3431 rajveer 8070 
    if self.ucx is not None:
1590 varun.gupt 8071 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8072 
      self.ucx.write(oprot)
8073 
      oprot.writeFieldEnd()
8074 
    oprot.writeFieldStop()
8075 
    oprot.writeStructEnd()
8076 
 
3431 rajveer 8077 
  def validate(self):
8078 
    return
8079 
 
8080 
 
1590 varun.gupt 8081 
  def __repr__(self):
8082 
    L = ['%s=%r' % (key, value)
8083 
      for key, value in self.__dict__.iteritems()]
8084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8085 
 
8086 
  def __eq__(self, other):
8087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8088 
 
8089 
  def __ne__(self, other):
8090 
    return not (self == other)
8091 
 
8092 
class getAllUserCommunications_args:
8093 
 
8094 
  thrift_spec = (
8095 
  )
8096 
 
8097 
  def read(self, iprot):
8098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8100 
      return
8101 
    iprot.readStructBegin()
8102 
    while True:
8103 
      (fname, ftype, fid) = iprot.readFieldBegin()
8104 
      if ftype == TType.STOP:
8105 
        break
8106 
      else:
8107 
        iprot.skip(ftype)
8108 
      iprot.readFieldEnd()
8109 
    iprot.readStructEnd()
8110 
 
8111 
  def write(self, oprot):
8112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8114 
      return
8115 
    oprot.writeStructBegin('getAllUserCommunications_args')
8116 
    oprot.writeFieldStop()
8117 
    oprot.writeStructEnd()
8118 
 
3431 rajveer 8119 
  def validate(self):
8120 
    return
8121 
 
8122 
 
1590 varun.gupt 8123 
  def __repr__(self):
8124 
    L = ['%s=%r' % (key, value)
8125 
      for key, value in self.__dict__.iteritems()]
8126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8127 
 
8128 
  def __eq__(self, other):
8129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8130 
 
8131 
  def __ne__(self, other):
8132 
    return not (self == other)
8133 
 
8134 
class getAllUserCommunications_result:
8135 
  """
8136 
  Attributes:
8137 
   - success
8138 
   - ucx
8139 
  """
8140 
 
8141 
  thrift_spec = (
8142 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8143 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8144 
  )
8145 
 
8146 
  def __init__(self, success=None, ucx=None,):
8147 
    self.success = success
8148 
    self.ucx = ucx
8149 
 
8150 
  def read(self, iprot):
8151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8153 
      return
8154 
    iprot.readStructBegin()
8155 
    while True:
8156 
      (fname, ftype, fid) = iprot.readFieldBegin()
8157 
      if ftype == TType.STOP:
8158 
        break
8159 
      if fid == 0:
8160 
        if ftype == TType.LIST:
8161 
          self.success = []
11592 amit.gupta 8162 
          (_etype114, _size111) = iprot.readListBegin()
8163 
          for _i115 in xrange(_size111):
8164 
            _elem116 = UserCommunication()
8165 
            _elem116.read(iprot)
8166 
            self.success.append(_elem116)
1590 varun.gupt 8167 
          iprot.readListEnd()
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      elif fid == 1:
8171 
        if ftype == TType.STRUCT:
8172 
          self.ucx = UserCommunicationException()
8173 
          self.ucx.read(iprot)
8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      else:
8177 
        iprot.skip(ftype)
8178 
      iprot.readFieldEnd()
8179 
    iprot.readStructEnd()
8180 
 
8181 
  def write(self, oprot):
8182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8184 
      return
8185 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8186 
    if self.success is not None:
1590 varun.gupt 8187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8189 
      for iter117 in self.success:
8190 
        iter117.write(oprot)
1590 varun.gupt 8191 
      oprot.writeListEnd()
8192 
      oprot.writeFieldEnd()
3431 rajveer 8193 
    if self.ucx is not None:
1590 varun.gupt 8194 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8195 
      self.ucx.write(oprot)
8196 
      oprot.writeFieldEnd()
8197 
    oprot.writeFieldStop()
8198 
    oprot.writeStructEnd()
8199 
 
3431 rajveer 8200 
  def validate(self):
8201 
    return
8202 
 
8203 
 
1590 varun.gupt 8204 
  def __repr__(self):
8205 
    L = ['%s=%r' % (key, value)
8206 
      for key, value in self.__dict__.iteritems()]
8207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8208 
 
8209 
  def __eq__(self, other):
8210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8211 
 
8212 
  def __ne__(self, other):
8213 
    return not (self == other)
8214 
 
5407 amar.kumar 8215 
class removeUserCommunication_args:
8216 
  """
8217 
  Attributes:
8218 
   - id
8219 
  """
8220 
 
8221 
  thrift_spec = (
8222 
    None, # 0
8223 
    (1, TType.I64, 'id', None, None, ), # 1
8224 
  )
8225 
 
8226 
  def __init__(self, id=None,):
8227 
    self.id = id
8228 
 
8229 
  def read(self, iprot):
8230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8232 
      return
8233 
    iprot.readStructBegin()
8234 
    while True:
8235 
      (fname, ftype, fid) = iprot.readFieldBegin()
8236 
      if ftype == TType.STOP:
8237 
        break
8238 
      if fid == 1:
8239 
        if ftype == TType.I64:
8240 
          self.id = iprot.readI64();
8241 
        else:
8242 
          iprot.skip(ftype)
8243 
      else:
8244 
        iprot.skip(ftype)
8245 
      iprot.readFieldEnd()
8246 
    iprot.readStructEnd()
8247 
 
8248 
  def write(self, oprot):
8249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8251 
      return
8252 
    oprot.writeStructBegin('removeUserCommunication_args')
8253 
    if self.id is not None:
8254 
      oprot.writeFieldBegin('id', TType.I64, 1)
8255 
      oprot.writeI64(self.id)
8256 
      oprot.writeFieldEnd()
8257 
    oprot.writeFieldStop()
8258 
    oprot.writeStructEnd()
8259 
 
8260 
  def validate(self):
8261 
    return
8262 
 
8263 
 
8264 
  def __repr__(self):
8265 
    L = ['%s=%r' % (key, value)
8266 
      for key, value in self.__dict__.iteritems()]
8267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8268 
 
8269 
  def __eq__(self, other):
8270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8271 
 
8272 
  def __ne__(self, other):
8273 
    return not (self == other)
8274 
 
8275 
class removeUserCommunication_result:
8276 
  """
8277 
  Attributes:
8278 
   - ucx
8279 
  """
8280 
 
8281 
  thrift_spec = (
8282 
    None, # 0
8283 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8284 
  )
8285 
 
8286 
  def __init__(self, ucx=None,):
8287 
    self.ucx = ucx
8288 
 
8289 
  def read(self, iprot):
8290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8292 
      return
8293 
    iprot.readStructBegin()
8294 
    while True:
8295 
      (fname, ftype, fid) = iprot.readFieldBegin()
8296 
      if ftype == TType.STOP:
8297 
        break
8298 
      if fid == 1:
8299 
        if ftype == TType.STRUCT:
8300 
          self.ucx = UserCommunicationException()
8301 
          self.ucx.read(iprot)
8302 
        else:
8303 
          iprot.skip(ftype)
8304 
      else:
8305 
        iprot.skip(ftype)
8306 
      iprot.readFieldEnd()
8307 
    iprot.readStructEnd()
8308 
 
8309 
  def write(self, oprot):
8310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8312 
      return
8313 
    oprot.writeStructBegin('removeUserCommunication_result')
8314 
    if self.ucx is not None:
8315 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8316 
      self.ucx.write(oprot)
8317 
      oprot.writeFieldEnd()
8318 
    oprot.writeFieldStop()
8319 
    oprot.writeStructEnd()
8320 
 
8321 
  def validate(self):
8322 
    return
8323 
 
8324 
 
8325 
  def __repr__(self):
8326 
    L = ['%s=%r' % (key, value)
8327 
      for key, value in self.__dict__.iteritems()]
8328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8329 
 
8330 
  def __eq__(self, other):
8331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8332 
 
8333 
  def __ne__(self, other):
8334 
    return not (self == other)
8335 
 
1845 vikas 8336 
class createMasterAffiliate_args:
8337 
  """
8338 
  Attributes:
8339 
   - name
1859 vikas 8340 
   - addedOn
1845 vikas 8341 
  """
8342 
 
8343 
  thrift_spec = (
8344 
    None, # 0
8345 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8346 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8347 
  )
8348 
 
1859 vikas 8349 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8350 
    self.name = name
1859 vikas 8351 
    self.addedOn = addedOn
1845 vikas 8352 
 
8353 
  def read(self, iprot):
8354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8356 
      return
8357 
    iprot.readStructBegin()
8358 
    while True:
8359 
      (fname, ftype, fid) = iprot.readFieldBegin()
8360 
      if ftype == TType.STOP:
8361 
        break
8362 
      if fid == 1:
8363 
        if ftype == TType.STRING:
8364 
          self.name = iprot.readString();
8365 
        else:
8366 
          iprot.skip(ftype)
1859 vikas 8367 
      elif fid == 2:
8368 
        if ftype == TType.I64:
8369 
          self.addedOn = iprot.readI64();
8370 
        else:
8371 
          iprot.skip(ftype)
1845 vikas 8372 
      else:
8373 
        iprot.skip(ftype)
8374 
      iprot.readFieldEnd()
8375 
    iprot.readStructEnd()
8376 
 
8377 
  def write(self, oprot):
8378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8380 
      return
8381 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8382 
    if self.name is not None:
1845 vikas 8383 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8384 
      oprot.writeString(self.name)
8385 
      oprot.writeFieldEnd()
3431 rajveer 8386 
    if self.addedOn is not None:
1859 vikas 8387 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8388 
      oprot.writeI64(self.addedOn)
8389 
      oprot.writeFieldEnd()
1845 vikas 8390 
    oprot.writeFieldStop()
8391 
    oprot.writeStructEnd()
8392 
 
3431 rajveer 8393 
  def validate(self):
8394 
    return
8395 
 
8396 
 
1845 vikas 8397 
  def __repr__(self):
8398 
    L = ['%s=%r' % (key, value)
8399 
      for key, value in self.__dict__.iteritems()]
8400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8401 
 
8402 
  def __eq__(self, other):
8403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8404 
 
8405 
  def __ne__(self, other):
8406 
    return not (self == other)
8407 
 
8408 
class createMasterAffiliate_result:
8409 
  """
8410 
  Attributes:
8411 
   - success
8412 
   - utx
8413 
  """
8414 
 
8415 
  thrift_spec = (
8416 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8417 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8418 
  )
8419 
 
8420 
  def __init__(self, success=None, utx=None,):
8421 
    self.success = success
8422 
    self.utx = utx
8423 
 
8424 
  def read(self, iprot):
8425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8427 
      return
8428 
    iprot.readStructBegin()
8429 
    while True:
8430 
      (fname, ftype, fid) = iprot.readFieldBegin()
8431 
      if ftype == TType.STOP:
8432 
        break
8433 
      if fid == 0:
8434 
        if ftype == TType.STRUCT:
8435 
          self.success = MasterAffiliate()
8436 
          self.success.read(iprot)
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      elif fid == 1:
8440 
        if ftype == TType.STRUCT:
1996 vikas 8441 
          self.utx = UserAffiliateException()
1845 vikas 8442 
          self.utx.read(iprot)
8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
8454 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8455 
    if self.success is not None:
1845 vikas 8456 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8457 
      self.success.write(oprot)
8458 
      oprot.writeFieldEnd()
3431 rajveer 8459 
    if self.utx is not None:
1845 vikas 8460 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8461 
      self.utx.write(oprot)
8462 
      oprot.writeFieldEnd()
8463 
    oprot.writeFieldStop()
8464 
    oprot.writeStructEnd()
8465 
 
3431 rajveer 8466 
  def validate(self):
8467 
    return
8468 
 
8469 
 
1845 vikas 8470 
  def __repr__(self):
8471 
    L = ['%s=%r' % (key, value)
8472 
      for key, value in self.__dict__.iteritems()]
8473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8474 
 
8475 
  def __eq__(self, other):
8476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8477 
 
8478 
  def __ne__(self, other):
8479 
    return not (self == other)
8480 
 
1899 vikas 8481 
class getAllMasterAffiliates_args:
8482 
 
8483 
  thrift_spec = (
8484 
  )
8485 
 
8486 
  def read(self, iprot):
8487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8489 
      return
8490 
    iprot.readStructBegin()
8491 
    while True:
8492 
      (fname, ftype, fid) = iprot.readFieldBegin()
8493 
      if ftype == TType.STOP:
8494 
        break
8495 
      else:
8496 
        iprot.skip(ftype)
8497 
      iprot.readFieldEnd()
8498 
    iprot.readStructEnd()
8499 
 
8500 
  def write(self, oprot):
8501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8503 
      return
8504 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8505 
    oprot.writeFieldStop()
8506 
    oprot.writeStructEnd()
8507 
 
3431 rajveer 8508 
  def validate(self):
8509 
    return
8510 
 
8511 
 
1899 vikas 8512 
  def __repr__(self):
8513 
    L = ['%s=%r' % (key, value)
8514 
      for key, value in self.__dict__.iteritems()]
8515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8516 
 
8517 
  def __eq__(self, other):
8518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8519 
 
8520 
  def __ne__(self, other):
8521 
    return not (self == other)
8522 
 
8523 
class getAllMasterAffiliates_result:
8524 
  """
8525 
  Attributes:
8526 
   - success
8527 
   - utx
8528 
  """
8529 
 
8530 
  thrift_spec = (
8531 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8532 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8533 
  )
8534 
 
8535 
  def __init__(self, success=None, utx=None,):
8536 
    self.success = success
8537 
    self.utx = utx
8538 
 
8539 
  def read(self, iprot):
8540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8542 
      return
8543 
    iprot.readStructBegin()
8544 
    while True:
8545 
      (fname, ftype, fid) = iprot.readFieldBegin()
8546 
      if ftype == TType.STOP:
8547 
        break
8548 
      if fid == 0:
8549 
        if ftype == TType.LIST:
8550 
          self.success = []
11592 amit.gupta 8551 
          (_etype121, _size118) = iprot.readListBegin()
8552 
          for _i122 in xrange(_size118):
8553 
            _elem123 = MasterAffiliate()
8554 
            _elem123.read(iprot)
8555 
            self.success.append(_elem123)
1899 vikas 8556 
          iprot.readListEnd()
8557 
        else:
8558 
          iprot.skip(ftype)
8559 
      elif fid == 1:
8560 
        if ftype == TType.STRUCT:
1996 vikas 8561 
          self.utx = UserAffiliateException()
1899 vikas 8562 
          self.utx.read(iprot)
8563 
        else:
8564 
          iprot.skip(ftype)
8565 
      else:
8566 
        iprot.skip(ftype)
8567 
      iprot.readFieldEnd()
8568 
    iprot.readStructEnd()
8569 
 
8570 
  def write(self, oprot):
8571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8573 
      return
8574 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8575 
    if self.success is not None:
1899 vikas 8576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8578 
      for iter124 in self.success:
8579 
        iter124.write(oprot)
1899 vikas 8580 
      oprot.writeListEnd()
8581 
      oprot.writeFieldEnd()
3431 rajveer 8582 
    if self.utx is not None:
1899 vikas 8583 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8584 
      self.utx.write(oprot)
8585 
      oprot.writeFieldEnd()
8586 
    oprot.writeFieldStop()
8587 
    oprot.writeStructEnd()
8588 
 
3431 rajveer 8589 
  def validate(self):
8590 
    return
8591 
 
8592 
 
1899 vikas 8593 
  def __repr__(self):
8594 
    L = ['%s=%r' % (key, value)
8595 
      for key, value in self.__dict__.iteritems()]
8596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8597 
 
8598 
  def __eq__(self, other):
8599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8600 
 
8601 
  def __ne__(self, other):
8602 
    return not (self == other)
8603 
 
1845 vikas 8604 
class getMasterAffiliateById_args:
8605 
  """
8606 
  Attributes:
8607 
   - id
8608 
  """
8609 
 
8610 
  thrift_spec = (
8611 
    None, # 0
8612 
    (1, TType.I64, 'id', None, None, ), # 1
8613 
  )
8614 
 
8615 
  def __init__(self, id=None,):
8616 
    self.id = id
8617 
 
8618 
  def read(self, iprot):
8619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8621 
      return
8622 
    iprot.readStructBegin()
8623 
    while True:
8624 
      (fname, ftype, fid) = iprot.readFieldBegin()
8625 
      if ftype == TType.STOP:
8626 
        break
8627 
      if fid == 1:
8628 
        if ftype == TType.I64:
8629 
          self.id = iprot.readI64();
8630 
        else:
8631 
          iprot.skip(ftype)
8632 
      else:
8633 
        iprot.skip(ftype)
8634 
      iprot.readFieldEnd()
8635 
    iprot.readStructEnd()
8636 
 
8637 
  def write(self, oprot):
8638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8640 
      return
8641 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8642 
    if self.id is not None:
1845 vikas 8643 
      oprot.writeFieldBegin('id', TType.I64, 1)
8644 
      oprot.writeI64(self.id)
8645 
      oprot.writeFieldEnd()
8646 
    oprot.writeFieldStop()
8647 
    oprot.writeStructEnd()
8648 
 
3431 rajveer 8649 
  def validate(self):
8650 
    return
8651 
 
8652 
 
1845 vikas 8653 
  def __repr__(self):
8654 
    L = ['%s=%r' % (key, value)
8655 
      for key, value in self.__dict__.iteritems()]
8656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8657 
 
8658 
  def __eq__(self, other):
8659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8660 
 
8661 
  def __ne__(self, other):
8662 
    return not (self == other)
8663 
 
8664 
class getMasterAffiliateById_result:
8665 
  """
8666 
  Attributes:
8667 
   - success
8668 
   - utx
8669 
  """
8670 
 
8671 
  thrift_spec = (
8672 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8673 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8674 
  )
8675 
 
8676 
  def __init__(self, success=None, utx=None,):
8677 
    self.success = success
8678 
    self.utx = utx
8679 
 
8680 
  def read(self, iprot):
8681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8683 
      return
8684 
    iprot.readStructBegin()
8685 
    while True:
8686 
      (fname, ftype, fid) = iprot.readFieldBegin()
8687 
      if ftype == TType.STOP:
8688 
        break
8689 
      if fid == 0:
8690 
        if ftype == TType.STRUCT:
8691 
          self.success = MasterAffiliate()
8692 
          self.success.read(iprot)
8693 
        else:
8694 
          iprot.skip(ftype)
8695 
      elif fid == 1:
8696 
        if ftype == TType.STRUCT:
1996 vikas 8697 
          self.utx = UserAffiliateException()
1845 vikas 8698 
          self.utx.read(iprot)
8699 
        else:
8700 
          iprot.skip(ftype)
8701 
      else:
8702 
        iprot.skip(ftype)
8703 
      iprot.readFieldEnd()
8704 
    iprot.readStructEnd()
8705 
 
8706 
  def write(self, oprot):
8707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8709 
      return
8710 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 8711 
    if self.success is not None:
1845 vikas 8712 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8713 
      self.success.write(oprot)
8714 
      oprot.writeFieldEnd()
3431 rajveer 8715 
    if self.utx is not None:
1845 vikas 8716 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8717 
      self.utx.write(oprot)
8718 
      oprot.writeFieldEnd()
8719 
    oprot.writeFieldStop()
8720 
    oprot.writeStructEnd()
8721 
 
3431 rajveer 8722 
  def validate(self):
8723 
    return
8724 
 
8725 
 
1845 vikas 8726 
  def __repr__(self):
8727 
    L = ['%s=%r' % (key, value)
8728 
      for key, value in self.__dict__.iteritems()]
8729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8730 
 
8731 
  def __eq__(self, other):
8732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8733 
 
8734 
  def __ne__(self, other):
8735 
    return not (self == other)
8736 
 
8737 
class getMasterAffiliateByName_args:
8738 
  """
8739 
  Attributes:
8740 
   - name
8741 
  """
8742 
 
8743 
  thrift_spec = (
8744 
    None, # 0
8745 
    (1, TType.STRING, 'name', None, None, ), # 1
8746 
  )
8747 
 
8748 
  def __init__(self, name=None,):
8749 
    self.name = name
8750 
 
8751 
  def read(self, iprot):
8752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8754 
      return
8755 
    iprot.readStructBegin()
8756 
    while True:
8757 
      (fname, ftype, fid) = iprot.readFieldBegin()
8758 
      if ftype == TType.STOP:
8759 
        break
8760 
      if fid == 1:
8761 
        if ftype == TType.STRING:
8762 
          self.name = iprot.readString();
8763 
        else:
8764 
          iprot.skip(ftype)
8765 
      else:
8766 
        iprot.skip(ftype)
8767 
      iprot.readFieldEnd()
8768 
    iprot.readStructEnd()
8769 
 
8770 
  def write(self, oprot):
8771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8773 
      return
8774 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 8775 
    if self.name is not None:
1845 vikas 8776 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8777 
      oprot.writeString(self.name)
8778 
      oprot.writeFieldEnd()
8779 
    oprot.writeFieldStop()
8780 
    oprot.writeStructEnd()
8781 
 
3431 rajveer 8782 
  def validate(self):
8783 
    return
8784 
 
8785 
 
1845 vikas 8786 
  def __repr__(self):
8787 
    L = ['%s=%r' % (key, value)
8788 
      for key, value in self.__dict__.iteritems()]
8789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8790 
 
8791 
  def __eq__(self, other):
8792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8793 
 
8794 
  def __ne__(self, other):
8795 
    return not (self == other)
8796 
 
8797 
class getMasterAffiliateByName_result:
8798 
  """
8799 
  Attributes:
8800 
   - success
8801 
   - utx
8802 
  """
8803 
 
8804 
  thrift_spec = (
8805 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8806 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8807 
  )
8808 
 
8809 
  def __init__(self, success=None, utx=None,):
8810 
    self.success = success
8811 
    self.utx = utx
8812 
 
8813 
  def read(self, iprot):
8814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8816 
      return
8817 
    iprot.readStructBegin()
8818 
    while True:
8819 
      (fname, ftype, fid) = iprot.readFieldBegin()
8820 
      if ftype == TType.STOP:
8821 
        break
8822 
      if fid == 0:
8823 
        if ftype == TType.STRUCT:
8824 
          self.success = MasterAffiliate()
8825 
          self.success.read(iprot)
8826 
        else:
8827 
          iprot.skip(ftype)
8828 
      elif fid == 1:
8829 
        if ftype == TType.STRUCT:
1996 vikas 8830 
          self.utx = UserAffiliateException()
1845 vikas 8831 
          self.utx.read(iprot)
8832 
        else:
8833 
          iprot.skip(ftype)
8834 
      else:
8835 
        iprot.skip(ftype)
8836 
      iprot.readFieldEnd()
8837 
    iprot.readStructEnd()
8838 
 
8839 
  def write(self, oprot):
8840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8842 
      return
8843 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 8844 
    if self.success is not None:
1845 vikas 8845 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8846 
      self.success.write(oprot)
8847 
      oprot.writeFieldEnd()
3431 rajveer 8848 
    if self.utx is not None:
1845 vikas 8849 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8850 
      self.utx.write(oprot)
8851 
      oprot.writeFieldEnd()
8852 
    oprot.writeFieldStop()
8853 
    oprot.writeStructEnd()
8854 
 
3431 rajveer 8855 
  def validate(self):
8856 
    return
8857 
 
8858 
 
1845 vikas 8859 
  def __repr__(self):
8860 
    L = ['%s=%r' % (key, value)
8861 
      for key, value in self.__dict__.iteritems()]
8862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8863 
 
8864 
  def __eq__(self, other):
8865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8866 
 
8867 
  def __ne__(self, other):
8868 
    return not (self == other)
8869 
 
8870 
class createAffiliate_args:
8871 
  """
8872 
  Attributes:
8873 
   - name
8874 
   - url
8875 
   - masterAffiliateId
1859 vikas 8876 
   - addedOn
1845 vikas 8877 
  """
8878 
 
8879 
  thrift_spec = (
8880 
    None, # 0
8881 
    (1, TType.STRING, 'name', None, None, ), # 1
8882 
    (2, TType.STRING, 'url', None, None, ), # 2
8883 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 8884 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 8885 
  )
8886 
 
1859 vikas 8887 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 8888 
    self.name = name
8889 
    self.url = url
8890 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 8891 
    self.addedOn = addedOn
1845 vikas 8892 
 
8893 
  def read(self, iprot):
8894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8896 
      return
8897 
    iprot.readStructBegin()
8898 
    while True:
8899 
      (fname, ftype, fid) = iprot.readFieldBegin()
8900 
      if ftype == TType.STOP:
8901 
        break
8902 
      if fid == 1:
8903 
        if ftype == TType.STRING:
8904 
          self.name = iprot.readString();
8905 
        else:
8906 
          iprot.skip(ftype)
8907 
      elif fid == 2:
8908 
        if ftype == TType.STRING:
8909 
          self.url = iprot.readString();
8910 
        else:
8911 
          iprot.skip(ftype)
8912 
      elif fid == 3:
8913 
        if ftype == TType.I64:
8914 
          self.masterAffiliateId = iprot.readI64();
8915 
        else:
8916 
          iprot.skip(ftype)
1859 vikas 8917 
      elif fid == 4:
8918 
        if ftype == TType.I64:
8919 
          self.addedOn = iprot.readI64();
8920 
        else:
8921 
          iprot.skip(ftype)
1845 vikas 8922 
      else:
8923 
        iprot.skip(ftype)
8924 
      iprot.readFieldEnd()
8925 
    iprot.readStructEnd()
8926 
 
8927 
  def write(self, oprot):
8928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8930 
      return
8931 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 8932 
    if self.name is not None:
1845 vikas 8933 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8934 
      oprot.writeString(self.name)
8935 
      oprot.writeFieldEnd()
3431 rajveer 8936 
    if self.url is not None:
1845 vikas 8937 
      oprot.writeFieldBegin('url', TType.STRING, 2)
8938 
      oprot.writeString(self.url)
8939 
      oprot.writeFieldEnd()
3431 rajveer 8940 
    if self.masterAffiliateId is not None:
1845 vikas 8941 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
8942 
      oprot.writeI64(self.masterAffiliateId)
8943 
      oprot.writeFieldEnd()
3431 rajveer 8944 
    if self.addedOn is not None:
1859 vikas 8945 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
8946 
      oprot.writeI64(self.addedOn)
8947 
      oprot.writeFieldEnd()
1845 vikas 8948 
    oprot.writeFieldStop()
8949 
    oprot.writeStructEnd()
8950 
 
3431 rajveer 8951 
  def validate(self):
8952 
    return
8953 
 
8954 
 
1845 vikas 8955 
  def __repr__(self):
8956 
    L = ['%s=%r' % (key, value)
8957 
      for key, value in self.__dict__.iteritems()]
8958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8959 
 
8960 
  def __eq__(self, other):
8961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8962 
 
8963 
  def __ne__(self, other):
8964 
    return not (self == other)
8965 
 
8966 
class createAffiliate_result:
8967 
  """
8968 
  Attributes:
8969 
   - success
8970 
   - utx
8971 
  """
8972 
 
8973 
  thrift_spec = (
8974 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8975 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8976 
  )
8977 
 
8978 
  def __init__(self, success=None, utx=None,):
8979 
    self.success = success
8980 
    self.utx = utx
8981 
 
8982 
  def read(self, iprot):
8983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8985 
      return
8986 
    iprot.readStructBegin()
8987 
    while True:
8988 
      (fname, ftype, fid) = iprot.readFieldBegin()
8989 
      if ftype == TType.STOP:
8990 
        break
8991 
      if fid == 0:
8992 
        if ftype == TType.STRUCT:
8993 
          self.success = Affiliate()
8994 
          self.success.read(iprot)
8995 
        else:
8996 
          iprot.skip(ftype)
8997 
      elif fid == 1:
8998 
        if ftype == TType.STRUCT:
1996 vikas 8999 
          self.utx = UserAffiliateException()
1845 vikas 9000 
          self.utx.read(iprot)
9001 
        else:
9002 
          iprot.skip(ftype)
9003 
      else:
9004 
        iprot.skip(ftype)
9005 
      iprot.readFieldEnd()
9006 
    iprot.readStructEnd()
9007 
 
9008 
  def write(self, oprot):
9009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9011 
      return
9012 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9013 
    if self.success is not None:
1845 vikas 9014 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9015 
      self.success.write(oprot)
9016 
      oprot.writeFieldEnd()
3431 rajveer 9017 
    if self.utx is not None:
1845 vikas 9018 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9019 
      self.utx.write(oprot)
9020 
      oprot.writeFieldEnd()
9021 
    oprot.writeFieldStop()
9022 
    oprot.writeStructEnd()
9023 
 
3431 rajveer 9024 
  def validate(self):
9025 
    return
9026 
 
9027 
 
1845 vikas 9028 
  def __repr__(self):
9029 
    L = ['%s=%r' % (key, value)
9030 
      for key, value in self.__dict__.iteritems()]
9031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9032 
 
9033 
  def __eq__(self, other):
9034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9035 
 
9036 
  def __ne__(self, other):
9037 
    return not (self == other)
9038 
 
9039 
class getAffiliateById_args:
9040 
  """
9041 
  Attributes:
9042 
   - id
9043 
  """
9044 
 
9045 
  thrift_spec = (
9046 
    None, # 0
9047 
    (1, TType.I64, 'id', None, None, ), # 1
9048 
  )
9049 
 
9050 
  def __init__(self, id=None,):
9051 
    self.id = id
9052 
 
9053 
  def read(self, iprot):
9054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9056 
      return
9057 
    iprot.readStructBegin()
9058 
    while True:
9059 
      (fname, ftype, fid) = iprot.readFieldBegin()
9060 
      if ftype == TType.STOP:
9061 
        break
9062 
      if fid == 1:
9063 
        if ftype == TType.I64:
9064 
          self.id = iprot.readI64();
9065 
        else:
9066 
          iprot.skip(ftype)
9067 
      else:
9068 
        iprot.skip(ftype)
9069 
      iprot.readFieldEnd()
9070 
    iprot.readStructEnd()
9071 
 
9072 
  def write(self, oprot):
9073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9075 
      return
9076 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9077 
    if self.id is not None:
1845 vikas 9078 
      oprot.writeFieldBegin('id', TType.I64, 1)
9079 
      oprot.writeI64(self.id)
9080 
      oprot.writeFieldEnd()
9081 
    oprot.writeFieldStop()
9082 
    oprot.writeStructEnd()
9083 
 
3431 rajveer 9084 
  def validate(self):
9085 
    return
9086 
 
9087 
 
1845 vikas 9088 
  def __repr__(self):
9089 
    L = ['%s=%r' % (key, value)
9090 
      for key, value in self.__dict__.iteritems()]
9091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9092 
 
9093 
  def __eq__(self, other):
9094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9095 
 
9096 
  def __ne__(self, other):
9097 
    return not (self == other)
9098 
 
9099 
class getAffiliateById_result:
9100 
  """
9101 
  Attributes:
9102 
   - success
9103 
   - utx
9104 
  """
9105 
 
9106 
  thrift_spec = (
9107 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9108 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9109 
  )
9110 
 
9111 
  def __init__(self, success=None, utx=None,):
9112 
    self.success = success
9113 
    self.utx = utx
9114 
 
9115 
  def read(self, iprot):
9116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9118 
      return
9119 
    iprot.readStructBegin()
9120 
    while True:
9121 
      (fname, ftype, fid) = iprot.readFieldBegin()
9122 
      if ftype == TType.STOP:
9123 
        break
9124 
      if fid == 0:
9125 
        if ftype == TType.STRUCT:
9126 
          self.success = Affiliate()
9127 
          self.success.read(iprot)
9128 
        else:
9129 
          iprot.skip(ftype)
9130 
      elif fid == 1:
9131 
        if ftype == TType.STRUCT:
1996 vikas 9132 
          self.utx = UserAffiliateException()
1845 vikas 9133 
          self.utx.read(iprot)
9134 
        else:
9135 
          iprot.skip(ftype)
9136 
      else:
9137 
        iprot.skip(ftype)
9138 
      iprot.readFieldEnd()
9139 
    iprot.readStructEnd()
9140 
 
9141 
  def write(self, oprot):
9142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9144 
      return
9145 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9146 
    if self.success is not None:
1845 vikas 9147 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9148 
      self.success.write(oprot)
9149 
      oprot.writeFieldEnd()
3431 rajveer 9150 
    if self.utx is not None:
1845 vikas 9151 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9152 
      self.utx.write(oprot)
9153 
      oprot.writeFieldEnd()
9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
3431 rajveer 9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
1845 vikas 9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
9172 
class getAffiliateByName_args:
9173 
  """
9174 
  Attributes:
9175 
   - name
9176 
  """
9177 
 
9178 
  thrift_spec = (
9179 
    None, # 0
9180 
    (1, TType.STRING, 'name', None, None, ), # 1
9181 
  )
9182 
 
9183 
  def __init__(self, name=None,):
9184 
    self.name = name
9185 
 
9186 
  def read(self, iprot):
9187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9189 
      return
9190 
    iprot.readStructBegin()
9191 
    while True:
9192 
      (fname, ftype, fid) = iprot.readFieldBegin()
9193 
      if ftype == TType.STOP:
9194 
        break
9195 
      if fid == 1:
9196 
        if ftype == TType.STRING:
9197 
          self.name = iprot.readString();
9198 
        else:
9199 
          iprot.skip(ftype)
9200 
      else:
9201 
        iprot.skip(ftype)
9202 
      iprot.readFieldEnd()
9203 
    iprot.readStructEnd()
9204 
 
9205 
  def write(self, oprot):
9206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9208 
      return
9209 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9210 
    if self.name is not None:
1845 vikas 9211 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9212 
      oprot.writeString(self.name)
9213 
      oprot.writeFieldEnd()
9214 
    oprot.writeFieldStop()
9215 
    oprot.writeStructEnd()
9216 
 
3431 rajveer 9217 
  def validate(self):
9218 
    return
9219 
 
9220 
 
1845 vikas 9221 
  def __repr__(self):
9222 
    L = ['%s=%r' % (key, value)
9223 
      for key, value in self.__dict__.iteritems()]
9224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9225 
 
9226 
  def __eq__(self, other):
9227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9228 
 
9229 
  def __ne__(self, other):
9230 
    return not (self == other)
9231 
 
9232 
class getAffiliateByName_result:
9233 
  """
9234 
  Attributes:
9235 
   - success
9236 
   - utx
9237 
  """
9238 
 
9239 
  thrift_spec = (
9240 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9241 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9242 
  )
9243 
 
9244 
  def __init__(self, success=None, utx=None,):
9245 
    self.success = success
9246 
    self.utx = utx
9247 
 
9248 
  def read(self, iprot):
9249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9251 
      return
9252 
    iprot.readStructBegin()
9253 
    while True:
9254 
      (fname, ftype, fid) = iprot.readFieldBegin()
9255 
      if ftype == TType.STOP:
9256 
        break
9257 
      if fid == 0:
9258 
        if ftype == TType.STRUCT:
9259 
          self.success = Affiliate()
9260 
          self.success.read(iprot)
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      elif fid == 1:
9264 
        if ftype == TType.STRUCT:
1996 vikas 9265 
          self.utx = UserAffiliateException()
1845 vikas 9266 
          self.utx.read(iprot)
9267 
        else:
9268 
          iprot.skip(ftype)
9269 
      else:
9270 
        iprot.skip(ftype)
9271 
      iprot.readFieldEnd()
9272 
    iprot.readStructEnd()
9273 
 
9274 
  def write(self, oprot):
9275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9277 
      return
9278 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9279 
    if self.success is not None:
1845 vikas 9280 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9281 
      self.success.write(oprot)
9282 
      oprot.writeFieldEnd()
3431 rajveer 9283 
    if self.utx is not None:
1845 vikas 9284 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9285 
      self.utx.write(oprot)
9286 
      oprot.writeFieldEnd()
9287 
    oprot.writeFieldStop()
9288 
    oprot.writeStructEnd()
9289 
 
3431 rajveer 9290 
  def validate(self):
9291 
    return
9292 
 
9293 
 
1845 vikas 9294 
  def __repr__(self):
9295 
    L = ['%s=%r' % (key, value)
9296 
      for key, value in self.__dict__.iteritems()]
9297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9298 
 
9299 
  def __eq__(self, other):
9300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9301 
 
9302 
  def __ne__(self, other):
9303 
    return not (self == other)
9304 
 
1996 vikas 9305 
class getTrackerById_args:
1845 vikas 9306 
  """
9307 
  Attributes:
9308 
   - id
9309 
  """
9310 
 
9311 
  thrift_spec = (
9312 
    None, # 0
9313 
    (1, TType.I64, 'id', None, None, ), # 1
9314 
  )
9315 
 
9316 
  def __init__(self, id=None,):
9317 
    self.id = id
9318 
 
9319 
  def read(self, iprot):
9320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9322 
      return
9323 
    iprot.readStructBegin()
9324 
    while True:
9325 
      (fname, ftype, fid) = iprot.readFieldBegin()
9326 
      if ftype == TType.STOP:
9327 
        break
9328 
      if fid == 1:
9329 
        if ftype == TType.I64:
9330 
          self.id = iprot.readI64();
9331 
        else:
9332 
          iprot.skip(ftype)
9333 
      else:
9334 
        iprot.skip(ftype)
9335 
      iprot.readFieldEnd()
9336 
    iprot.readStructEnd()
9337 
 
9338 
  def write(self, oprot):
9339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9341 
      return
1996 vikas 9342 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9343 
    if self.id is not None:
1845 vikas 9344 
      oprot.writeFieldBegin('id', TType.I64, 1)
9345 
      oprot.writeI64(self.id)
9346 
      oprot.writeFieldEnd()
9347 
    oprot.writeFieldStop()
9348 
    oprot.writeStructEnd()
9349 
 
3431 rajveer 9350 
  def validate(self):
9351 
    return
9352 
 
9353 
 
1845 vikas 9354 
  def __repr__(self):
9355 
    L = ['%s=%r' % (key, value)
9356 
      for key, value in self.__dict__.iteritems()]
9357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9358 
 
9359 
  def __eq__(self, other):
9360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9361 
 
9362 
  def __ne__(self, other):
9363 
    return not (self == other)
9364 
 
9365 
class getTrackerById_result:
9366 
  """
9367 
  Attributes:
9368 
   - success
9369 
   - utx
9370 
  """
9371 
 
9372 
  thrift_spec = (
9373 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9374 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9375 
  )
9376 
 
9377 
  def __init__(self, success=None, utx=None,):
9378 
    self.success = success
9379 
    self.utx = utx
9380 
 
9381 
  def read(self, iprot):
9382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9384 
      return
9385 
    iprot.readStructBegin()
9386 
    while True:
9387 
      (fname, ftype, fid) = iprot.readFieldBegin()
9388 
      if ftype == TType.STOP:
9389 
        break
9390 
      if fid == 0:
9391 
        if ftype == TType.STRUCT:
9392 
          self.success = Tracker()
9393 
          self.success.read(iprot)
9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      elif fid == 1:
9397 
        if ftype == TType.STRUCT:
1996 vikas 9398 
          self.utx = UserAffiliateException()
1845 vikas 9399 
          self.utx.read(iprot)
9400 
        else:
9401 
          iprot.skip(ftype)
9402 
      else:
9403 
        iprot.skip(ftype)
9404 
      iprot.readFieldEnd()
9405 
    iprot.readStructEnd()
9406 
 
9407 
  def write(self, oprot):
9408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9410 
      return
9411 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9412 
    if self.success is not None:
1845 vikas 9413 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9414 
      self.success.write(oprot)
9415 
      oprot.writeFieldEnd()
3431 rajveer 9416 
    if self.utx is not None:
1845 vikas 9417 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9418 
      self.utx.write(oprot)
9419 
      oprot.writeFieldEnd()
9420 
    oprot.writeFieldStop()
9421 
    oprot.writeStructEnd()
9422 
 
3431 rajveer 9423 
  def validate(self):
9424 
    return
9425 
 
9426 
 
1845 vikas 9427 
  def __repr__(self):
9428 
    L = ['%s=%r' % (key, value)
9429 
      for key, value in self.__dict__.iteritems()]
9430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9431 
 
9432 
  def __eq__(self, other):
9433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9434 
 
9435 
  def __ne__(self, other):
9436 
    return not (self == other)
9437 
 
1996 vikas 9438 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9439 
  """
9440 
  Attributes:
1996 vikas 9441 
   - id
1845 vikas 9442 
  """
9443 
 
9444 
  thrift_spec = (
9445 
    None, # 0
1996 vikas 9446 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9447 
  )
9448 
 
1996 vikas 9449 
  def __init__(self, id=None,):
9450 
    self.id = id
1845 vikas 9451 
 
9452 
  def read(self, iprot):
9453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9455 
      return
9456 
    iprot.readStructBegin()
9457 
    while True:
9458 
      (fname, ftype, fid) = iprot.readFieldBegin()
9459 
      if ftype == TType.STOP:
9460 
        break
9461 
      if fid == 1:
9462 
        if ftype == TType.I64:
1996 vikas 9463 
          self.id = iprot.readI64();
1845 vikas 9464 
        else:
9465 
          iprot.skip(ftype)
9466 
      else:
9467 
        iprot.skip(ftype)
9468 
      iprot.readFieldEnd()
9469 
    iprot.readStructEnd()
9470 
 
9471 
  def write(self, oprot):
9472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9474 
      return
1996 vikas 9475 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9476 
    if self.id is not None:
1996 vikas 9477 
      oprot.writeFieldBegin('id', TType.I64, 1)
9478 
      oprot.writeI64(self.id)
1845 vikas 9479 
      oprot.writeFieldEnd()
9480 
    oprot.writeFieldStop()
9481 
    oprot.writeStructEnd()
9482 
 
3431 rajveer 9483 
  def validate(self):
9484 
    return
9485 
 
9486 
 
1845 vikas 9487 
  def __repr__(self):
9488 
    L = ['%s=%r' % (key, value)
9489 
      for key, value in self.__dict__.iteritems()]
9490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9491 
 
9492 
  def __eq__(self, other):
9493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9494 
 
9495 
  def __ne__(self, other):
9496 
    return not (self == other)
9497 
 
1996 vikas 9498 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9499 
  """
9500 
  Attributes:
9501 
   - success
9502 
   - utx
9503 
  """
9504 
 
9505 
  thrift_spec = (
1996 vikas 9506 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9507 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9508 
  )
9509 
 
9510 
  def __init__(self, success=None, utx=None,):
9511 
    self.success = success
9512 
    self.utx = utx
9513 
 
9514 
  def read(self, iprot):
9515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9517 
      return
9518 
    iprot.readStructBegin()
9519 
    while True:
9520 
      (fname, ftype, fid) = iprot.readFieldBegin()
9521 
      if ftype == TType.STOP:
9522 
        break
9523 
      if fid == 0:
9524 
        if ftype == TType.LIST:
9525 
          self.success = []
11592 amit.gupta 9526 
          (_etype128, _size125) = iprot.readListBegin()
9527 
          for _i129 in xrange(_size125):
9528 
            _elem130 = Affiliate()
9529 
            _elem130.read(iprot)
9530 
            self.success.append(_elem130)
1845 vikas 9531 
          iprot.readListEnd()
9532 
        else:
9533 
          iprot.skip(ftype)
9534 
      elif fid == 1:
9535 
        if ftype == TType.STRUCT:
1996 vikas 9536 
          self.utx = UserAffiliateException()
1845 vikas 9537 
          self.utx.read(iprot)
9538 
        else:
9539 
          iprot.skip(ftype)
9540 
      else:
9541 
        iprot.skip(ftype)
9542 
      iprot.readFieldEnd()
9543 
    iprot.readStructEnd()
9544 
 
9545 
  def write(self, oprot):
9546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9548 
      return
1996 vikas 9549 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9550 
    if self.success is not None:
1845 vikas 9551 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9552 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9553 
      for iter131 in self.success:
9554 
        iter131.write(oprot)
1845 vikas 9555 
      oprot.writeListEnd()
9556 
      oprot.writeFieldEnd()
3431 rajveer 9557 
    if self.utx is not None:
1845 vikas 9558 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9559 
      self.utx.write(oprot)
9560 
      oprot.writeFieldEnd()
9561 
    oprot.writeFieldStop()
9562 
    oprot.writeStructEnd()
9563 
 
3431 rajveer 9564 
  def validate(self):
9565 
    return
9566 
 
9567 
 
1845 vikas 9568 
  def __repr__(self):
9569 
    L = ['%s=%r' % (key, value)
9570 
      for key, value in self.__dict__.iteritems()]
9571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9572 
 
9573 
  def __eq__(self, other):
9574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9575 
 
9576 
  def __ne__(self, other):
9577 
    return not (self == other)
9578 
 
9579 
class addTrackLog_args:
9580 
  """
9581 
  Attributes:
1996 vikas 9582 
   - affiliateId
1845 vikas 9583 
   - userId
9584 
   - event
9585 
   - url
9586 
   - data
1859 vikas 9587 
   - addedOn
1845 vikas 9588 
  """
9589 
 
9590 
  thrift_spec = (
9591 
    None, # 0
1996 vikas 9592 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9593 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9594 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9595 
    (4, TType.STRING, 'url', None, None, ), # 4
9596 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9597 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9598 
  )
9599 
 
1996 vikas 9600 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9601 
    self.affiliateId = affiliateId
1845 vikas 9602 
    self.userId = userId
9603 
    self.event = event
9604 
    self.url = url
9605 
    self.data = data
1859 vikas 9606 
    self.addedOn = addedOn
1845 vikas 9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      if fid == 1:
9618 
        if ftype == TType.I64:
1996 vikas 9619 
          self.affiliateId = iprot.readI64();
1845 vikas 9620 
        else:
9621 
          iprot.skip(ftype)
9622 
      elif fid == 2:
9623 
        if ftype == TType.I64:
9624 
          self.userId = iprot.readI64();
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      elif fid == 3:
3378 vikas 9628 
        if ftype == TType.I32:
9629 
          self.event = iprot.readI32();
1845 vikas 9630 
        else:
9631 
          iprot.skip(ftype)
9632 
      elif fid == 4:
9633 
        if ftype == TType.STRING:
9634 
          self.url = iprot.readString();
9635 
        else:
9636 
          iprot.skip(ftype)
9637 
      elif fid == 5:
9638 
        if ftype == TType.STRING:
9639 
          self.data = iprot.readString();
9640 
        else:
9641 
          iprot.skip(ftype)
1859 vikas 9642 
      elif fid == 6:
9643 
        if ftype == TType.I64:
9644 
          self.addedOn = iprot.readI64();
9645 
        else:
9646 
          iprot.skip(ftype)
1845 vikas 9647 
      else:
9648 
        iprot.skip(ftype)
9649 
      iprot.readFieldEnd()
9650 
    iprot.readStructEnd()
9651 
 
9652 
  def write(self, oprot):
9653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9655 
      return
9656 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9657 
    if self.affiliateId is not None:
1996 vikas 9658 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9659 
      oprot.writeI64(self.affiliateId)
1845 vikas 9660 
      oprot.writeFieldEnd()
3431 rajveer 9661 
    if self.userId is not None:
1845 vikas 9662 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9663 
      oprot.writeI64(self.userId)
9664 
      oprot.writeFieldEnd()
3431 rajveer 9665 
    if self.event is not None:
3378 vikas 9666 
      oprot.writeFieldBegin('event', TType.I32, 3)
9667 
      oprot.writeI32(self.event)
1845 vikas 9668 
      oprot.writeFieldEnd()
3431 rajveer 9669 
    if self.url is not None:
1845 vikas 9670 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9671 
      oprot.writeString(self.url)
9672 
      oprot.writeFieldEnd()
3431 rajveer 9673 
    if self.data is not None:
1845 vikas 9674 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9675 
      oprot.writeString(self.data)
9676 
      oprot.writeFieldEnd()
3431 rajveer 9677 
    if self.addedOn is not None:
1859 vikas 9678 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9679 
      oprot.writeI64(self.addedOn)
9680 
      oprot.writeFieldEnd()
1845 vikas 9681 
    oprot.writeFieldStop()
9682 
    oprot.writeStructEnd()
9683 
 
3431 rajveer 9684 
  def validate(self):
9685 
    return
9686 
 
9687 
 
1845 vikas 9688 
  def __repr__(self):
9689 
    L = ['%s=%r' % (key, value)
9690 
      for key, value in self.__dict__.iteritems()]
9691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9692 
 
9693 
  def __eq__(self, other):
9694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9695 
 
9696 
  def __ne__(self, other):
9697 
    return not (self == other)
9698 
 
9699 
class addTrackLog_result:
9700 
  """
9701 
  Attributes:
9702 
   - success
9703 
   - utx
9704 
  """
9705 
 
9706 
  thrift_spec = (
9707 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 9708 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9709 
  )
9710 
 
9711 
  def __init__(self, success=None, utx=None,):
9712 
    self.success = success
9713 
    self.utx = utx
9714 
 
9715 
  def read(self, iprot):
9716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9718 
      return
9719 
    iprot.readStructBegin()
9720 
    while True:
9721 
      (fname, ftype, fid) = iprot.readFieldBegin()
9722 
      if ftype == TType.STOP:
9723 
        break
9724 
      if fid == 0:
9725 
        if ftype == TType.I64:
9726 
          self.success = iprot.readI64();
9727 
        else:
9728 
          iprot.skip(ftype)
9729 
      elif fid == 1:
9730 
        if ftype == TType.STRUCT:
1996 vikas 9731 
          self.utx = UserAffiliateException()
1845 vikas 9732 
          self.utx.read(iprot)
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      else:
9736 
        iprot.skip(ftype)
9737 
      iprot.readFieldEnd()
9738 
    iprot.readStructEnd()
9739 
 
9740 
  def write(self, oprot):
9741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9743 
      return
9744 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 9745 
    if self.success is not None:
1845 vikas 9746 
      oprot.writeFieldBegin('success', TType.I64, 0)
9747 
      oprot.writeI64(self.success)
9748 
      oprot.writeFieldEnd()
3431 rajveer 9749 
    if self.utx is not None:
1845 vikas 9750 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9751 
      self.utx.write(oprot)
9752 
      oprot.writeFieldEnd()
9753 
    oprot.writeFieldStop()
9754 
    oprot.writeStructEnd()
9755 
 
3431 rajveer 9756 
  def validate(self):
9757 
    return
9758 
 
9759 
 
1845 vikas 9760 
  def __repr__(self):
9761 
    L = ['%s=%r' % (key, value)
9762 
      for key, value in self.__dict__.iteritems()]
9763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9764 
 
9765 
  def __eq__(self, other):
9766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9767 
 
9768 
  def __ne__(self, other):
9769 
    return not (self == other)
9770 
 
9771 
class getTrackLogById_args:
9772 
  """
9773 
  Attributes:
9774 
   - id
9775 
  """
9776 
 
9777 
  thrift_spec = (
9778 
    None, # 0
9779 
    (1, TType.I64, 'id', None, None, ), # 1
9780 
  )
9781 
 
9782 
  def __init__(self, id=None,):
9783 
    self.id = id
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 1:
9795 
        if ftype == TType.I64:
9796 
          self.id = iprot.readI64();
9797 
        else:
9798 
          iprot.skip(ftype)
9799 
      else:
9800 
        iprot.skip(ftype)
9801 
      iprot.readFieldEnd()
9802 
    iprot.readStructEnd()
9803 
 
9804 
  def write(self, oprot):
9805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9807 
      return
9808 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 9809 
    if self.id is not None:
1845 vikas 9810 
      oprot.writeFieldBegin('id', TType.I64, 1)
9811 
      oprot.writeI64(self.id)
9812 
      oprot.writeFieldEnd()
9813 
    oprot.writeFieldStop()
9814 
    oprot.writeStructEnd()
9815 
 
3431 rajveer 9816 
  def validate(self):
9817 
    return
9818 
 
9819 
 
1845 vikas 9820 
  def __repr__(self):
9821 
    L = ['%s=%r' % (key, value)
9822 
      for key, value in self.__dict__.iteritems()]
9823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9824 
 
9825 
  def __eq__(self, other):
9826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9827 
 
9828 
  def __ne__(self, other):
9829 
    return not (self == other)
9830 
 
9831 
class getTrackLogById_result:
9832 
  """
9833 
  Attributes:
9834 
   - success
9835 
   - utx
9836 
  """
9837 
 
9838 
  thrift_spec = (
9839 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 9840 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9841 
  )
9842 
 
9843 
  def __init__(self, success=None, utx=None,):
9844 
    self.success = success
9845 
    self.utx = utx
9846 
 
9847 
  def read(self, iprot):
9848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9850 
      return
9851 
    iprot.readStructBegin()
9852 
    while True:
9853 
      (fname, ftype, fid) = iprot.readFieldBegin()
9854 
      if ftype == TType.STOP:
9855 
        break
9856 
      if fid == 0:
9857 
        if ftype == TType.STRUCT:
9858 
          self.success = TrackLog()
9859 
          self.success.read(iprot)
9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      elif fid == 1:
9863 
        if ftype == TType.STRUCT:
1996 vikas 9864 
          self.utx = UserAffiliateException()
1845 vikas 9865 
          self.utx.read(iprot)
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      else:
9869 
        iprot.skip(ftype)
9870 
      iprot.readFieldEnd()
9871 
    iprot.readStructEnd()
9872 
 
9873 
  def write(self, oprot):
9874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9876 
      return
9877 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 9878 
    if self.success is not None:
1845 vikas 9879 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9880 
      self.success.write(oprot)
9881 
      oprot.writeFieldEnd()
3431 rajveer 9882 
    if self.utx is not None:
1845 vikas 9883 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9884 
      self.utx.write(oprot)
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
3431 rajveer 9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
1845 vikas 9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
1996 vikas 9904 
class getTrackLogsByAffiliate_args:
1845 vikas 9905 
  """
9906 
  Attributes:
1996 vikas 9907 
   - affiliateId
3293 vikas 9908 
   - startDate
9909 
   - endDate
1845 vikas 9910 
  """
9911 
 
9912 
  thrift_spec = (
9913 
    None, # 0
1996 vikas 9914 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 9915 
    (2, TType.I64, 'startDate', None, None, ), # 2
9916 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 9917 
  )
9918 
 
3293 vikas 9919 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 9920 
    self.affiliateId = affiliateId
3293 vikas 9921 
    self.startDate = startDate
9922 
    self.endDate = endDate
1845 vikas 9923 
 
9924 
  def read(self, iprot):
9925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9927 
      return
9928 
    iprot.readStructBegin()
9929 
    while True:
9930 
      (fname, ftype, fid) = iprot.readFieldBegin()
9931 
      if ftype == TType.STOP:
9932 
        break
9933 
      if fid == 1:
9934 
        if ftype == TType.I64:
1996 vikas 9935 
          self.affiliateId = iprot.readI64();
1845 vikas 9936 
        else:
9937 
          iprot.skip(ftype)
3293 vikas 9938 
      elif fid == 2:
9939 
        if ftype == TType.I64:
9940 
          self.startDate = iprot.readI64();
9941 
        else:
9942 
          iprot.skip(ftype)
9943 
      elif fid == 3:
9944 
        if ftype == TType.I64:
9945 
          self.endDate = iprot.readI64();
9946 
        else:
9947 
          iprot.skip(ftype)
1845 vikas 9948 
      else:
9949 
        iprot.skip(ftype)
9950 
      iprot.readFieldEnd()
9951 
    iprot.readStructEnd()
9952 
 
9953 
  def write(self, oprot):
9954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9956 
      return
1996 vikas 9957 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 9958 
    if self.affiliateId is not None:
1996 vikas 9959 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9960 
      oprot.writeI64(self.affiliateId)
1845 vikas 9961 
      oprot.writeFieldEnd()
3431 rajveer 9962 
    if self.startDate is not None:
3293 vikas 9963 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
9964 
      oprot.writeI64(self.startDate)
9965 
      oprot.writeFieldEnd()
3431 rajveer 9966 
    if self.endDate is not None:
3293 vikas 9967 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
9968 
      oprot.writeI64(self.endDate)
9969 
      oprot.writeFieldEnd()
1845 vikas 9970 
    oprot.writeFieldStop()
9971 
    oprot.writeStructEnd()
9972 
 
3431 rajveer 9973 
  def validate(self):
9974 
    return
9975 
 
9976 
 
1845 vikas 9977 
  def __repr__(self):
9978 
    L = ['%s=%r' % (key, value)
9979 
      for key, value in self.__dict__.iteritems()]
9980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9981 
 
9982 
  def __eq__(self, other):
9983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9984 
 
9985 
  def __ne__(self, other):
9986 
    return not (self == other)
9987 
 
1996 vikas 9988 
class getTrackLogsByAffiliate_result:
1845 vikas 9989 
  """
9990 
  Attributes:
9991 
   - success
9992 
   - utx
9993 
  """
9994 
 
9995 
  thrift_spec = (
9996 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9997 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9998 
  )
9999 
 
10000 
  def __init__(self, success=None, utx=None,):
10001 
    self.success = success
10002 
    self.utx = utx
10003 
 
10004 
  def read(self, iprot):
10005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10007 
      return
10008 
    iprot.readStructBegin()
10009 
    while True:
10010 
      (fname, ftype, fid) = iprot.readFieldBegin()
10011 
      if ftype == TType.STOP:
10012 
        break
10013 
      if fid == 0:
10014 
        if ftype == TType.LIST:
10015 
          self.success = []
11592 amit.gupta 10016 
          (_etype135, _size132) = iprot.readListBegin()
10017 
          for _i136 in xrange(_size132):
10018 
            _elem137 = TrackLog()
10019 
            _elem137.read(iprot)
10020 
            self.success.append(_elem137)
1845 vikas 10021 
          iprot.readListEnd()
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 1:
10025 
        if ftype == TType.STRUCT:
1996 vikas 10026 
          self.utx = UserAffiliateException()
1845 vikas 10027 
          self.utx.read(iprot)
10028 
        else:
10029 
          iprot.skip(ftype)
10030 
      else:
10031 
        iprot.skip(ftype)
10032 
      iprot.readFieldEnd()
10033 
    iprot.readStructEnd()
10034 
 
10035 
  def write(self, oprot):
10036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10038 
      return
1996 vikas 10039 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10040 
    if self.success is not None:
1845 vikas 10041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10043 
      for iter138 in self.success:
10044 
        iter138.write(oprot)
1845 vikas 10045 
      oprot.writeListEnd()
10046 
      oprot.writeFieldEnd()
3431 rajveer 10047 
    if self.utx is not None:
1845 vikas 10048 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10049 
      self.utx.write(oprot)
10050 
      oprot.writeFieldEnd()
10051 
    oprot.writeFieldStop()
10052 
    oprot.writeStructEnd()
10053 
 
3431 rajveer 10054 
  def validate(self):
10055 
    return
10056 
 
10057 
 
1845 vikas 10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
10069 
class getTrackLogsByUser_args:
10070 
  """
10071 
  Attributes:
10072 
   - userId
10073 
  """
10074 
 
10075 
  thrift_spec = (
10076 
    None, # 0
10077 
    (1, TType.I64, 'userId', None, None, ), # 1
10078 
  )
10079 
 
10080 
  def __init__(self, userId=None,):
10081 
    self.userId = userId
10082 
 
10083 
  def read(self, iprot):
10084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10086 
      return
10087 
    iprot.readStructBegin()
10088 
    while True:
10089 
      (fname, ftype, fid) = iprot.readFieldBegin()
10090 
      if ftype == TType.STOP:
10091 
        break
10092 
      if fid == 1:
10093 
        if ftype == TType.I64:
10094 
          self.userId = iprot.readI64();
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10107 
    if self.userId is not None:
1845 vikas 10108 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10109 
      oprot.writeI64(self.userId)
10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
3431 rajveer 10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
1845 vikas 10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
10129 
class getTrackLogsByUser_result:
10130 
  """
10131 
  Attributes:
10132 
   - success
10133 
   - utx
10134 
  """
10135 
 
10136 
  thrift_spec = (
10137 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10138 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10139 
  )
10140 
 
10141 
  def __init__(self, success=None, utx=None,):
10142 
    self.success = success
10143 
    self.utx = utx
10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      if fid == 0:
10155 
        if ftype == TType.LIST:
10156 
          self.success = []
11592 amit.gupta 10157 
          (_etype142, _size139) = iprot.readListBegin()
10158 
          for _i143 in xrange(_size139):
10159 
            _elem144 = TrackLog()
10160 
            _elem144.read(iprot)
10161 
            self.success.append(_elem144)
1845 vikas 10162 
          iprot.readListEnd()
10163 
        else:
10164 
          iprot.skip(ftype)
10165 
      elif fid == 1:
10166 
        if ftype == TType.STRUCT:
1996 vikas 10167 
          self.utx = UserAffiliateException()
1845 vikas 10168 
          self.utx.read(iprot)
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      else:
10172 
        iprot.skip(ftype)
10173 
      iprot.readFieldEnd()
10174 
    iprot.readStructEnd()
10175 
 
10176 
  def write(self, oprot):
10177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10179 
      return
10180 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10181 
    if self.success is not None:
1845 vikas 10182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10183 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10184 
      for iter145 in self.success:
10185 
        iter145.write(oprot)
1845 vikas 10186 
      oprot.writeListEnd()
10187 
      oprot.writeFieldEnd()
3431 rajveer 10188 
    if self.utx is not None:
1845 vikas 10189 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10190 
      self.utx.write(oprot)
10191 
      oprot.writeFieldEnd()
10192 
    oprot.writeFieldStop()
10193 
    oprot.writeStructEnd()
10194 
 
3431 rajveer 10195 
  def validate(self):
10196 
    return
10197 
 
10198 
 
1845 vikas 10199 
  def __repr__(self):
10200 
    L = ['%s=%r' % (key, value)
10201 
      for key, value in self.__dict__.iteritems()]
10202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10203 
 
10204 
  def __eq__(self, other):
10205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10206 
 
10207 
  def __ne__(self, other):
10208 
    return not (self == other)
10209 
 
10210 
class getTrackLogs_args:
10211 
  """
10212 
  Attributes:
10213 
   - userId
10214 
   - event
10215 
   - url
10216 
  """
10217 
 
10218 
  thrift_spec = (
10219 
    None, # 0
1996 vikas 10220 
    (1, TType.I64, 'userId', None, None, ), # 1
10221 
    (2, TType.STRING, 'event', None, None, ), # 2
10222 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10223 
  )
10224 
 
1996 vikas 10225 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10226 
    self.userId = userId
10227 
    self.event = event
10228 
    self.url = url
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 1:
10240 
        if ftype == TType.I64:
1996 vikas 10241 
          self.userId = iprot.readI64();
1845 vikas 10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      elif fid == 2:
10245 
        if ftype == TType.STRING:
10246 
          self.event = iprot.readString();
10247 
        else:
10248 
          iprot.skip(ftype)
1996 vikas 10249 
      elif fid == 3:
1845 vikas 10250 
        if ftype == TType.STRING:
10251 
          self.url = iprot.readString();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      else:
10255 
        iprot.skip(ftype)
10256 
      iprot.readFieldEnd()
10257 
    iprot.readStructEnd()
10258 
 
10259 
  def write(self, oprot):
10260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10262 
      return
10263 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10264 
    if self.userId is not None:
1996 vikas 10265 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10266 
      oprot.writeI64(self.userId)
10267 
      oprot.writeFieldEnd()
3431 rajveer 10268 
    if self.event is not None:
1996 vikas 10269 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10270 
      oprot.writeString(self.event)
10271 
      oprot.writeFieldEnd()
3431 rajveer 10272 
    if self.url is not None:
1996 vikas 10273 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10274 
      oprot.writeString(self.url)
10275 
      oprot.writeFieldEnd()
10276 
    oprot.writeFieldStop()
10277 
    oprot.writeStructEnd()
10278 
 
3431 rajveer 10279 
  def validate(self):
10280 
    return
10281 
 
10282 
 
1845 vikas 10283 
  def __repr__(self):
10284 
    L = ['%s=%r' % (key, value)
10285 
      for key, value in self.__dict__.iteritems()]
10286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10287 
 
10288 
  def __eq__(self, other):
10289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10290 
 
10291 
  def __ne__(self, other):
10292 
    return not (self == other)
10293 
 
10294 
class getTrackLogs_result:
10295 
  """
10296 
  Attributes:
10297 
   - success
10298 
   - utx
10299 
  """
10300 
 
10301 
  thrift_spec = (
10302 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10303 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10304 
  )
10305 
 
10306 
  def __init__(self, success=None, utx=None,):
10307 
    self.success = success
10308 
    self.utx = utx
10309 
 
10310 
  def read(self, iprot):
10311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10313 
      return
10314 
    iprot.readStructBegin()
10315 
    while True:
10316 
      (fname, ftype, fid) = iprot.readFieldBegin()
10317 
      if ftype == TType.STOP:
10318 
        break
10319 
      if fid == 0:
10320 
        if ftype == TType.LIST:
10321 
          self.success = []
11592 amit.gupta 10322 
          (_etype149, _size146) = iprot.readListBegin()
10323 
          for _i150 in xrange(_size146):
10324 
            _elem151 = TrackLog()
10325 
            _elem151.read(iprot)
10326 
            self.success.append(_elem151)
1845 vikas 10327 
          iprot.readListEnd()
10328 
        else:
10329 
          iprot.skip(ftype)
10330 
      elif fid == 1:
10331 
        if ftype == TType.STRUCT:
1996 vikas 10332 
          self.utx = UserAffiliateException()
1845 vikas 10333 
          self.utx.read(iprot)
10334 
        else:
10335 
          iprot.skip(ftype)
10336 
      else:
10337 
        iprot.skip(ftype)
10338 
      iprot.readFieldEnd()
10339 
    iprot.readStructEnd()
10340 
 
10341 
  def write(self, oprot):
10342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10344 
      return
10345 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10346 
    if self.success is not None:
1845 vikas 10347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10348 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10349 
      for iter152 in self.success:
10350 
        iter152.write(oprot)
1845 vikas 10351 
      oprot.writeListEnd()
10352 
      oprot.writeFieldEnd()
3431 rajveer 10353 
    if self.utx is not None:
1845 vikas 10354 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10355 
      self.utx.write(oprot)
10356 
      oprot.writeFieldEnd()
10357 
    oprot.writeFieldStop()
10358 
    oprot.writeStructEnd()
10359 
 
3431 rajveer 10360 
  def validate(self):
10361 
    return
10362 
 
10363 
 
1845 vikas 10364 
  def __repr__(self):
10365 
    L = ['%s=%r' % (key, value)
10366 
      for key, value in self.__dict__.iteritems()]
10367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10368 
 
10369 
  def __eq__(self, other):
10370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10371 
 
10372 
  def __ne__(self, other):
10373 
    return not (self == other)
10374 
 
559 chandransh 10375 
class getCurrentCart_args:
94 ashish 10376 
  """
10377 
  Attributes:
559 chandransh 10378 
   - userId
10379 
  """
10380 
 
10381 
  thrift_spec = (
10382 
    None, # 0
10383 
    (1, TType.I64, 'userId', None, None, ), # 1
10384 
  )
10385 
 
10386 
  def __init__(self, userId=None,):
10387 
    self.userId = userId
10388 
 
10389 
  def read(self, iprot):
10390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10392 
      return
10393 
    iprot.readStructBegin()
10394 
    while True:
10395 
      (fname, ftype, fid) = iprot.readFieldBegin()
10396 
      if ftype == TType.STOP:
10397 
        break
10398 
      if fid == 1:
10399 
        if ftype == TType.I64:
10400 
          self.userId = iprot.readI64();
10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
10412 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10413 
    if self.userId is not None:
559 chandransh 10414 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10415 
      oprot.writeI64(self.userId)
10416 
      oprot.writeFieldEnd()
10417 
    oprot.writeFieldStop()
10418 
    oprot.writeStructEnd()
10419 
 
3431 rajveer 10420 
  def validate(self):
10421 
    return
10422 
 
10423 
 
559 chandransh 10424 
  def __repr__(self):
10425 
    L = ['%s=%r' % (key, value)
10426 
      for key, value in self.__dict__.iteritems()]
10427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10428 
 
10429 
  def __eq__(self, other):
10430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10431 
 
10432 
  def __ne__(self, other):
10433 
    return not (self == other)
10434 
 
10435 
class getCurrentCart_result:
10436 
  """
10437 
  Attributes:
94 ashish 10438 
   - success
559 chandransh 10439 
   - scx
94 ashish 10440 
  """
10441 
 
10442 
  thrift_spec = (
559 chandransh 10443 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10444 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10445 
  )
10446 
 
559 chandransh 10447 
  def __init__(self, success=None, scx=None,):
94 ashish 10448 
    self.success = success
559 chandransh 10449 
    self.scx = scx
94 ashish 10450 
 
10451 
  def read(self, iprot):
10452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10454 
      return
10455 
    iprot.readStructBegin()
10456 
    while True:
10457 
      (fname, ftype, fid) = iprot.readFieldBegin()
10458 
      if ftype == TType.STOP:
10459 
        break
10460 
      if fid == 0:
559 chandransh 10461 
        if ftype == TType.STRUCT:
10462 
          self.success = Cart()
10463 
          self.success.read(iprot)
94 ashish 10464 
        else:
10465 
          iprot.skip(ftype)
10466 
      elif fid == 1:
10467 
        if ftype == TType.STRUCT:
559 chandransh 10468 
          self.scx = ShoppingCartException()
10469 
          self.scx.read(iprot)
94 ashish 10470 
        else:
10471 
          iprot.skip(ftype)
10472 
      else:
10473 
        iprot.skip(ftype)
10474 
      iprot.readFieldEnd()
10475 
    iprot.readStructEnd()
10476 
 
10477 
  def write(self, oprot):
10478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10480 
      return
559 chandransh 10481 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10482 
    if self.success is not None:
559 chandransh 10483 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10484 
      self.success.write(oprot)
94 ashish 10485 
      oprot.writeFieldEnd()
3431 rajveer 10486 
    if self.scx is not None:
559 chandransh 10487 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10488 
      self.scx.write(oprot)
94 ashish 10489 
      oprot.writeFieldEnd()
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
3431 rajveer 10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
94 ashish 10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
559 chandransh 10508 
class getCart_args:
504 rajveer 10509 
  """
10510 
  Attributes:
559 chandransh 10511 
   - cartId
504 rajveer 10512 
  """
10513 
 
10514 
  thrift_spec = (
10515 
    None, # 0
559 chandransh 10516 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10517 
  )
10518 
 
559 chandransh 10519 
  def __init__(self, cartId=None,):
10520 
    self.cartId = cartId
504 rajveer 10521 
 
10522 
  def read(self, iprot):
10523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10525 
      return
10526 
    iprot.readStructBegin()
10527 
    while True:
10528 
      (fname, ftype, fid) = iprot.readFieldBegin()
10529 
      if ftype == TType.STOP:
10530 
        break
10531 
      if fid == 1:
10532 
        if ftype == TType.I64:
559 chandransh 10533 
          self.cartId = iprot.readI64();
504 rajveer 10534 
        else:
10535 
          iprot.skip(ftype)
10536 
      else:
10537 
        iprot.skip(ftype)
10538 
      iprot.readFieldEnd()
10539 
    iprot.readStructEnd()
10540 
 
10541 
  def write(self, oprot):
10542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10544 
      return
559 chandransh 10545 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10546 
    if self.cartId is not None:
559 chandransh 10547 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10548 
      oprot.writeI64(self.cartId)
504 rajveer 10549 
      oprot.writeFieldEnd()
10550 
    oprot.writeFieldStop()
10551 
    oprot.writeStructEnd()
10552 
 
3431 rajveer 10553 
  def validate(self):
10554 
    return
10555 
 
10556 
 
504 rajveer 10557 
  def __repr__(self):
10558 
    L = ['%s=%r' % (key, value)
10559 
      for key, value in self.__dict__.iteritems()]
10560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10561 
 
10562 
  def __eq__(self, other):
10563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10564 
 
10565 
  def __ne__(self, other):
10566 
    return not (self == other)
10567 
 
559 chandransh 10568 
class getCart_result:
504 rajveer 10569 
  """
10570 
  Attributes:
10571 
   - success
559 chandransh 10572 
   - scx
504 rajveer 10573 
  """
10574 
 
10575 
  thrift_spec = (
559 chandransh 10576 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10577 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10578 
  )
10579 
 
559 chandransh 10580 
  def __init__(self, success=None, scx=None,):
504 rajveer 10581 
    self.success = success
559 chandransh 10582 
    self.scx = scx
504 rajveer 10583 
 
10584 
  def read(self, iprot):
10585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10587 
      return
10588 
    iprot.readStructBegin()
10589 
    while True:
10590 
      (fname, ftype, fid) = iprot.readFieldBegin()
10591 
      if ftype == TType.STOP:
10592 
        break
10593 
      if fid == 0:
559 chandransh 10594 
        if ftype == TType.STRUCT:
10595 
          self.success = Cart()
10596 
          self.success.read(iprot)
504 rajveer 10597 
        else:
10598 
          iprot.skip(ftype)
10599 
      elif fid == 1:
10600 
        if ftype == TType.STRUCT:
559 chandransh 10601 
          self.scx = ShoppingCartException()
10602 
          self.scx.read(iprot)
504 rajveer 10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      else:
10606 
        iprot.skip(ftype)
10607 
      iprot.readFieldEnd()
10608 
    iprot.readStructEnd()
10609 
 
10610 
  def write(self, oprot):
10611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10613 
      return
559 chandransh 10614 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10615 
    if self.success is not None:
559 chandransh 10616 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10617 
      self.success.write(oprot)
504 rajveer 10618 
      oprot.writeFieldEnd()
3431 rajveer 10619 
    if self.scx is not None:
559 chandransh 10620 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10621 
      self.scx.write(oprot)
504 rajveer 10622 
      oprot.writeFieldEnd()
10623 
    oprot.writeFieldStop()
10624 
    oprot.writeStructEnd()
10625 
 
3431 rajveer 10626 
  def validate(self):
10627 
    return
10628 
 
10629 
 
504 rajveer 10630 
  def __repr__(self):
10631 
    L = ['%s=%r' % (key, value)
10632 
      for key, value in self.__dict__.iteritems()]
10633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10634 
 
10635 
  def __eq__(self, other):
10636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10637 
 
10638 
  def __ne__(self, other):
10639 
    return not (self == other)
10640 
 
559 chandransh 10641 
class getCartsByTime_args:
10642 
  """
10643 
  Attributes:
10644 
   - from_time
10645 
   - to_time
10646 
   - status
10647 
  """
10648 
 
10649 
  thrift_spec = (
10650 
    None, # 0
10651 
    (1, TType.I64, 'from_time', None, None, ), # 1
10652 
    (2, TType.I64, 'to_time', None, None, ), # 2
10653 
    (3, TType.I32, 'status', None, None, ), # 3
10654 
  )
10655 
 
10656 
  def __init__(self, from_time=None, to_time=None, status=None,):
10657 
    self.from_time = from_time
10658 
    self.to_time = to_time
10659 
    self.status = status
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 1:
94 ashish 10671 
        if ftype == TType.I64:
559 chandransh 10672 
          self.from_time = iprot.readI64();
94 ashish 10673 
        else:
10674 
          iprot.skip(ftype)
122 ashish 10675 
      elif fid == 2:
559 chandransh 10676 
        if ftype == TType.I64:
10677 
          self.to_time = iprot.readI64();
122 ashish 10678 
        else:
10679 
          iprot.skip(ftype)
559 chandransh 10680 
      elif fid == 3:
10681 
        if ftype == TType.I32:
10682 
          self.status = iprot.readI32();
10683 
        else:
10684 
          iprot.skip(ftype)
94 ashish 10685 
      else:
10686 
        iprot.skip(ftype)
10687 
      iprot.readFieldEnd()
10688 
    iprot.readStructEnd()
10689 
 
10690 
  def write(self, oprot):
10691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10693 
      return
559 chandransh 10694 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10695 
    if self.from_time is not None:
559 chandransh 10696 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10697 
      oprot.writeI64(self.from_time)
94 ashish 10698 
      oprot.writeFieldEnd()
3431 rajveer 10699 
    if self.to_time is not None:
559 chandransh 10700 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10701 
      oprot.writeI64(self.to_time)
122 ashish 10702 
      oprot.writeFieldEnd()
3431 rajveer 10703 
    if self.status is not None:
559 chandransh 10704 
      oprot.writeFieldBegin('status', TType.I32, 3)
10705 
      oprot.writeI32(self.status)
10706 
      oprot.writeFieldEnd()
94 ashish 10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
3431 rajveer 10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
94 ashish 10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
559 chandransh 10725 
class getCartsByTime_result:
94 ashish 10726 
  """
10727 
  Attributes:
10728 
   - success
559 chandransh 10729 
   - scx
94 ashish 10730 
  """
10731 
 
10732 
  thrift_spec = (
559 chandransh 10733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10734 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10735 
  )
10736 
 
559 chandransh 10737 
  def __init__(self, success=None, scx=None,):
94 ashish 10738 
    self.success = success
559 chandransh 10739 
    self.scx = scx
94 ashish 10740 
 
10741 
  def read(self, iprot):
10742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10744 
      return
10745 
    iprot.readStructBegin()
10746 
    while True:
10747 
      (fname, ftype, fid) = iprot.readFieldBegin()
10748 
      if ftype == TType.STOP:
10749 
        break
10750 
      if fid == 0:
559 chandransh 10751 
        if ftype == TType.LIST:
10752 
          self.success = []
11592 amit.gupta 10753 
          (_etype156, _size153) = iprot.readListBegin()
10754 
          for _i157 in xrange(_size153):
10755 
            _elem158 = Cart()
10756 
            _elem158.read(iprot)
10757 
            self.success.append(_elem158)
559 chandransh 10758 
          iprot.readListEnd()
94 ashish 10759 
        else:
10760 
          iprot.skip(ftype)
10761 
      elif fid == 1:
10762 
        if ftype == TType.STRUCT:
559 chandransh 10763 
          self.scx = ShoppingCartException()
10764 
          self.scx.read(iprot)
94 ashish 10765 
        else:
10766 
          iprot.skip(ftype)
10767 
      else:
10768 
        iprot.skip(ftype)
10769 
      iprot.readFieldEnd()
10770 
    iprot.readStructEnd()
10771 
 
10772 
  def write(self, oprot):
10773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10775 
      return
559 chandransh 10776 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 10777 
    if self.success is not None:
559 chandransh 10778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10780 
      for iter159 in self.success:
10781 
        iter159.write(oprot)
559 chandransh 10782 
      oprot.writeListEnd()
94 ashish 10783 
      oprot.writeFieldEnd()
3431 rajveer 10784 
    if self.scx is not None:
559 chandransh 10785 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10786 
      self.scx.write(oprot)
94 ashish 10787 
      oprot.writeFieldEnd()
10788 
    oprot.writeFieldStop()
10789 
    oprot.writeStructEnd()
10790 
 
3431 rajveer 10791 
  def validate(self):
10792 
    return
10793 
 
10794 
 
94 ashish 10795 
  def __repr__(self):
10796 
    L = ['%s=%r' % (key, value)
10797 
      for key, value in self.__dict__.iteritems()]
10798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10799 
 
10800 
  def __eq__(self, other):
10801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10802 
 
10803 
  def __ne__(self, other):
10804 
    return not (self == other)
10805 
 
559 chandransh 10806 
class addItemToCart_args:
10807 
  """
10808 
  Attributes:
10809 
   - cartId
10810 
   - itemId
10811 
   - quantity
3557 rajveer 10812 
   - sourceId
559 chandransh 10813 
  """
10814 
 
10815 
  thrift_spec = (
10816 
    None, # 0
10817 
    (1, TType.I64, 'cartId', None, None, ), # 1
10818 
    (2, TType.I64, 'itemId', None, None, ), # 2
10819 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 10820 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 10821 
  )
10822 
 
3557 rajveer 10823 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 10824 
    self.cartId = cartId
10825 
    self.itemId = itemId
10826 
    self.quantity = quantity
3557 rajveer 10827 
    self.sourceId = sourceId
559 chandransh 10828 
 
10829 
  def read(self, iprot):
10830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10832 
      return
10833 
    iprot.readStructBegin()
10834 
    while True:
10835 
      (fname, ftype, fid) = iprot.readFieldBegin()
10836 
      if ftype == TType.STOP:
10837 
        break
10838 
      if fid == 1:
10839 
        if ftype == TType.I64:
10840 
          self.cartId = iprot.readI64();
10841 
        else:
10842 
          iprot.skip(ftype)
10843 
      elif fid == 2:
10844 
        if ftype == TType.I64:
10845 
          self.itemId = iprot.readI64();
10846 
        else:
10847 
          iprot.skip(ftype)
10848 
      elif fid == 3:
10849 
        if ftype == TType.I64:
10850 
          self.quantity = iprot.readI64();
10851 
        else:
10852 
          iprot.skip(ftype)
3557 rajveer 10853 
      elif fid == 4:
10854 
        if ftype == TType.I64:
10855 
          self.sourceId = iprot.readI64();
10856 
        else:
10857 
          iprot.skip(ftype)
559 chandransh 10858 
      else:
10859 
        iprot.skip(ftype)
10860 
      iprot.readFieldEnd()
10861 
    iprot.readStructEnd()
10862 
 
10863 
  def write(self, oprot):
10864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10866 
      return
10867 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 10868 
    if self.cartId is not None:
559 chandransh 10869 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10870 
      oprot.writeI64(self.cartId)
10871 
      oprot.writeFieldEnd()
3431 rajveer 10872 
    if self.itemId is not None:
559 chandransh 10873 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10874 
      oprot.writeI64(self.itemId)
10875 
      oprot.writeFieldEnd()
3431 rajveer 10876 
    if self.quantity is not None:
559 chandransh 10877 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10878 
      oprot.writeI64(self.quantity)
10879 
      oprot.writeFieldEnd()
3557 rajveer 10880 
    if self.sourceId is not None:
10881 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
10882 
      oprot.writeI64(self.sourceId)
10883 
      oprot.writeFieldEnd()
559 chandransh 10884 
    oprot.writeFieldStop()
10885 
    oprot.writeStructEnd()
10886 
 
3431 rajveer 10887 
  def validate(self):
10888 
    return
10889 
 
10890 
 
559 chandransh 10891 
  def __repr__(self):
10892 
    L = ['%s=%r' % (key, value)
10893 
      for key, value in self.__dict__.iteritems()]
10894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10895 
 
10896 
  def __eq__(self, other):
10897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10898 
 
10899 
  def __ne__(self, other):
10900 
    return not (self == other)
10901 
 
10902 
class addItemToCart_result:
10903 
  """
10904 
  Attributes:
2035 rajveer 10905 
   - success
559 chandransh 10906 
   - scx
10907 
  """
10908 
 
10909 
  thrift_spec = (
2035 rajveer 10910 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10911 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10912 
  )
10913 
 
2035 rajveer 10914 
  def __init__(self, success=None, scx=None,):
10915 
    self.success = success
559 chandransh 10916 
    self.scx = scx
10917 
 
10918 
  def read(self, iprot):
10919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10921 
      return
10922 
    iprot.readStructBegin()
10923 
    while True:
10924 
      (fname, ftype, fid) = iprot.readFieldBegin()
10925 
      if ftype == TType.STOP:
10926 
        break
2035 rajveer 10927 
      if fid == 0:
10928 
        if ftype == TType.STRING:
10929 
          self.success = iprot.readString();
10930 
        else:
10931 
          iprot.skip(ftype)
10932 
      elif fid == 1:
559 chandransh 10933 
        if ftype == TType.STRUCT:
10934 
          self.scx = ShoppingCartException()
10935 
          self.scx.read(iprot)
10936 
        else:
10937 
          iprot.skip(ftype)
10938 
      else:
10939 
        iprot.skip(ftype)
10940 
      iprot.readFieldEnd()
10941 
    iprot.readStructEnd()
10942 
 
10943 
  def write(self, oprot):
10944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10946 
      return
10947 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 10948 
    if self.success is not None:
2035 rajveer 10949 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10950 
      oprot.writeString(self.success)
10951 
      oprot.writeFieldEnd()
3431 rajveer 10952 
    if self.scx is not None:
559 chandransh 10953 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10954 
      self.scx.write(oprot)
10955 
      oprot.writeFieldEnd()
10956 
    oprot.writeFieldStop()
10957 
    oprot.writeStructEnd()
10958 
 
3431 rajveer 10959 
  def validate(self):
10960 
    return
10961 
 
10962 
 
559 chandransh 10963 
  def __repr__(self):
10964 
    L = ['%s=%r' % (key, value)
10965 
      for key, value in self.__dict__.iteritems()]
10966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10967 
 
10968 
  def __eq__(self, other):
10969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10970 
 
10971 
  def __ne__(self, other):
10972 
    return not (self == other)
10973 
 
10974 
class deleteItemFromCart_args:
10975 
  """
10976 
  Attributes:
10977 
   - cartId
10978 
   - itemId
10979 
  """
10980 
 
10981 
  thrift_spec = (
10982 
    None, # 0
10983 
    (1, TType.I64, 'cartId', None, None, ), # 1
10984 
    (2, TType.I64, 'itemId', None, None, ), # 2
10985 
  )
10986 
 
10987 
  def __init__(self, cartId=None, itemId=None,):
10988 
    self.cartId = cartId
10989 
    self.itemId = itemId
10990 
 
10991 
  def read(self, iprot):
10992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10994 
      return
10995 
    iprot.readStructBegin()
10996 
    while True:
10997 
      (fname, ftype, fid) = iprot.readFieldBegin()
10998 
      if ftype == TType.STOP:
10999 
        break
11000 
      if fid == 1:
11001 
        if ftype == TType.I64:
11002 
          self.cartId = iprot.readI64();
11003 
        else:
11004 
          iprot.skip(ftype)
11005 
      elif fid == 2:
11006 
        if ftype == TType.I64:
11007 
          self.itemId = iprot.readI64();
11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      else:
11011 
        iprot.skip(ftype)
11012 
      iprot.readFieldEnd()
11013 
    iprot.readStructEnd()
11014 
 
11015 
  def write(self, oprot):
11016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11018 
      return
11019 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11020 
    if self.cartId is not None:
559 chandransh 11021 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11022 
      oprot.writeI64(self.cartId)
11023 
      oprot.writeFieldEnd()
3431 rajveer 11024 
    if self.itemId is not None:
559 chandransh 11025 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11026 
      oprot.writeI64(self.itemId)
11027 
      oprot.writeFieldEnd()
11028 
    oprot.writeFieldStop()
11029 
    oprot.writeStructEnd()
11030 
 
3431 rajveer 11031 
  def validate(self):
11032 
    return
11033 
 
11034 
 
559 chandransh 11035 
  def __repr__(self):
11036 
    L = ['%s=%r' % (key, value)
11037 
      for key, value in self.__dict__.iteritems()]
11038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11039 
 
11040 
  def __eq__(self, other):
11041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11042 
 
11043 
  def __ne__(self, other):
11044 
    return not (self == other)
11045 
 
11046 
class deleteItemFromCart_result:
11047 
  """
11048 
  Attributes:
11049 
   - scx
11050 
  """
11051 
 
11052 
  thrift_spec = (
11053 
    None, # 0
11054 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11055 
  )
11056 
 
11057 
  def __init__(self, scx=None,):
11058 
    self.scx = scx
11059 
 
11060 
  def read(self, iprot):
11061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11063 
      return
11064 
    iprot.readStructBegin()
11065 
    while True:
11066 
      (fname, ftype, fid) = iprot.readFieldBegin()
11067 
      if ftype == TType.STOP:
11068 
        break
11069 
      if fid == 1:
11070 
        if ftype == TType.STRUCT:
11071 
          self.scx = ShoppingCartException()
11072 
          self.scx.read(iprot)
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11085 
    if self.scx is not None:
559 chandransh 11086 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11087 
      self.scx.write(oprot)
11088 
      oprot.writeFieldEnd()
11089 
    oprot.writeFieldStop()
11090 
    oprot.writeStructEnd()
11091 
 
3431 rajveer 11092 
  def validate(self):
11093 
    return
11094 
 
11095 
 
559 chandransh 11096 
  def __repr__(self):
11097 
    L = ['%s=%r' % (key, value)
11098 
      for key, value in self.__dict__.iteritems()]
11099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11100 
 
11101 
  def __eq__(self, other):
11102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11103 
 
11104 
  def __ne__(self, other):
11105 
    return not (self == other)
11106 
 
11107 
class addAddressToCart_args:
11108 
  """
11109 
  Attributes:
11110 
   - cartId
11111 
   - addressId
11112 
  """
11113 
 
11114 
  thrift_spec = (
11115 
    None, # 0
11116 
    (1, TType.I64, 'cartId', None, None, ), # 1
11117 
    (2, TType.I64, 'addressId', None, None, ), # 2
11118 
  )
11119 
 
11120 
  def __init__(self, cartId=None, addressId=None,):
11121 
    self.cartId = cartId
11122 
    self.addressId = addressId
11123 
 
11124 
  def read(self, iprot):
11125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11127 
      return
11128 
    iprot.readStructBegin()
11129 
    while True:
11130 
      (fname, ftype, fid) = iprot.readFieldBegin()
11131 
      if ftype == TType.STOP:
11132 
        break
11133 
      if fid == 1:
11134 
        if ftype == TType.I64:
11135 
          self.cartId = iprot.readI64();
11136 
        else:
11137 
          iprot.skip(ftype)
11138 
      elif fid == 2:
11139 
        if ftype == TType.I64:
11140 
          self.addressId = iprot.readI64();
11141 
        else:
11142 
          iprot.skip(ftype)
11143 
      else:
11144 
        iprot.skip(ftype)
11145 
      iprot.readFieldEnd()
11146 
    iprot.readStructEnd()
11147 
 
11148 
  def write(self, oprot):
11149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11151 
      return
11152 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11153 
    if self.cartId is not None:
559 chandransh 11154 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11155 
      oprot.writeI64(self.cartId)
11156 
      oprot.writeFieldEnd()
3431 rajveer 11157 
    if self.addressId is not None:
559 chandransh 11158 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11159 
      oprot.writeI64(self.addressId)
11160 
      oprot.writeFieldEnd()
11161 
    oprot.writeFieldStop()
11162 
    oprot.writeStructEnd()
11163 
 
3431 rajveer 11164 
  def validate(self):
11165 
    return
11166 
 
11167 
 
559 chandransh 11168 
  def __repr__(self):
11169 
    L = ['%s=%r' % (key, value)
11170 
      for key, value in self.__dict__.iteritems()]
11171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11172 
 
11173 
  def __eq__(self, other):
11174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11175 
 
11176 
  def __ne__(self, other):
11177 
    return not (self == other)
11178 
 
11179 
class addAddressToCart_result:
575 chandransh 11180 
  """
11181 
  Attributes:
11182 
   - scx
11183 
  """
559 chandransh 11184 
 
11185 
  thrift_spec = (
575 chandransh 11186 
    None, # 0
11187 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11188 
  )
11189 
 
575 chandransh 11190 
  def __init__(self, scx=None,):
11191 
    self.scx = scx
11192 
 
559 chandransh 11193 
  def read(self, iprot):
11194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11196 
      return
11197 
    iprot.readStructBegin()
11198 
    while True:
11199 
      (fname, ftype, fid) = iprot.readFieldBegin()
11200 
      if ftype == TType.STOP:
11201 
        break
575 chandransh 11202 
      if fid == 1:
11203 
        if ftype == TType.STRUCT:
11204 
          self.scx = ShoppingCartException()
11205 
          self.scx.read(iprot)
11206 
        else:
11207 
          iprot.skip(ftype)
559 chandransh 11208 
      else:
11209 
        iprot.skip(ftype)
11210 
      iprot.readFieldEnd()
11211 
    iprot.readStructEnd()
11212 
 
11213 
  def write(self, oprot):
11214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11216 
      return
11217 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11218 
    if self.scx is not None:
575 chandransh 11219 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11220 
      self.scx.write(oprot)
11221 
      oprot.writeFieldEnd()
559 chandransh 11222 
    oprot.writeFieldStop()
11223 
    oprot.writeStructEnd()
11224 
 
3431 rajveer 11225 
  def validate(self):
11226 
    return
11227 
 
11228 
 
559 chandransh 11229 
  def __repr__(self):
11230 
    L = ['%s=%r' % (key, value)
11231 
      for key, value in self.__dict__.iteritems()]
11232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11233 
 
11234 
  def __eq__(self, other):
11235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11236 
 
11237 
  def __ne__(self, other):
11238 
    return not (self == other)
11239 
 
5553 rajveer 11240 
class addStoreToCart_args:
11241 
  """
11242 
  Attributes:
11243 
   - cartId
11244 
   - storeId
11245 
  """
11246 
 
11247 
  thrift_spec = (
11248 
    None, # 0
11249 
    (1, TType.I64, 'cartId', None, None, ), # 1
11250 
    (2, TType.I64, 'storeId', None, None, ), # 2
11251 
  )
11252 
 
11253 
  def __init__(self, cartId=None, storeId=None,):
11254 
    self.cartId = cartId
11255 
    self.storeId = storeId
11256 
 
11257 
  def read(self, iprot):
11258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11260 
      return
11261 
    iprot.readStructBegin()
11262 
    while True:
11263 
      (fname, ftype, fid) = iprot.readFieldBegin()
11264 
      if ftype == TType.STOP:
11265 
        break
11266 
      if fid == 1:
11267 
        if ftype == TType.I64:
11268 
          self.cartId = iprot.readI64();
11269 
        else:
11270 
          iprot.skip(ftype)
11271 
      elif fid == 2:
11272 
        if ftype == TType.I64:
11273 
          self.storeId = iprot.readI64();
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      else:
11277 
        iprot.skip(ftype)
11278 
      iprot.readFieldEnd()
11279 
    iprot.readStructEnd()
11280 
 
11281 
  def write(self, oprot):
11282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11284 
      return
11285 
    oprot.writeStructBegin('addStoreToCart_args')
11286 
    if self.cartId is not None:
11287 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11288 
      oprot.writeI64(self.cartId)
11289 
      oprot.writeFieldEnd()
11290 
    if self.storeId is not None:
11291 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11292 
      oprot.writeI64(self.storeId)
11293 
      oprot.writeFieldEnd()
11294 
    oprot.writeFieldStop()
11295 
    oprot.writeStructEnd()
11296 
 
11297 
  def validate(self):
11298 
    return
11299 
 
11300 
 
11301 
  def __repr__(self):
11302 
    L = ['%s=%r' % (key, value)
11303 
      for key, value in self.__dict__.iteritems()]
11304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11305 
 
11306 
  def __eq__(self, other):
11307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11308 
 
11309 
  def __ne__(self, other):
11310 
    return not (self == other)
11311 
 
11312 
class addStoreToCart_result:
11313 
  """
11314 
  Attributes:
11315 
   - scx
11316 
  """
11317 
 
11318 
  thrift_spec = (
11319 
    None, # 0
11320 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11321 
  )
11322 
 
11323 
  def __init__(self, scx=None,):
11324 
    self.scx = scx
11325 
 
11326 
  def read(self, iprot):
11327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11329 
      return
11330 
    iprot.readStructBegin()
11331 
    while True:
11332 
      (fname, ftype, fid) = iprot.readFieldBegin()
11333 
      if ftype == TType.STOP:
11334 
        break
11335 
      if fid == 1:
11336 
        if ftype == TType.STRUCT:
11337 
          self.scx = ShoppingCartException()
11338 
          self.scx.read(iprot)
11339 
        else:
11340 
          iprot.skip(ftype)
11341 
      else:
11342 
        iprot.skip(ftype)
11343 
      iprot.readFieldEnd()
11344 
    iprot.readStructEnd()
11345 
 
11346 
  def write(self, oprot):
11347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11349 
      return
11350 
    oprot.writeStructBegin('addStoreToCart_result')
11351 
    if self.scx is not None:
11352 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11353 
      self.scx.write(oprot)
11354 
      oprot.writeFieldEnd()
11355 
    oprot.writeFieldStop()
11356 
    oprot.writeStructEnd()
11357 
 
11358 
  def validate(self):
11359 
    return
11360 
 
11361 
 
11362 
  def __repr__(self):
11363 
    L = ['%s=%r' % (key, value)
11364 
      for key, value in self.__dict__.iteritems()]
11365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11366 
 
11367 
  def __eq__(self, other):
11368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11369 
 
11370 
  def __ne__(self, other):
11371 
    return not (self == other)
11372 
 
1976 varun.gupt 11373 
class applyCouponToCart_args:
11374 
  """
11375 
  Attributes:
6922 anupam.sin 11376 
   - cart
1976 varun.gupt 11377 
   - couponCode
11378 
  """
11379 
 
11380 
  thrift_spec = (
11381 
    None, # 0
6922 anupam.sin 11382 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11383 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11384 
  )
11385 
 
6922 anupam.sin 11386 
  def __init__(self, cart=None, couponCode=None,):
11387 
    self.cart = cart
1976 varun.gupt 11388 
    self.couponCode = couponCode
11389 
 
11390 
  def read(self, iprot):
11391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11393 
      return
11394 
    iprot.readStructBegin()
11395 
    while True:
11396 
      (fname, ftype, fid) = iprot.readFieldBegin()
11397 
      if ftype == TType.STOP:
11398 
        break
11399 
      if fid == 1:
6922 anupam.sin 11400 
        if ftype == TType.STRUCT:
11401 
          self.cart = Cart()
11402 
          self.cart.read(iprot)
1976 varun.gupt 11403 
        else:
11404 
          iprot.skip(ftype)
11405 
      elif fid == 2:
11406 
        if ftype == TType.STRING:
11407 
          self.couponCode = iprot.readString();
11408 
        else:
11409 
          iprot.skip(ftype)
11410 
      else:
11411 
        iprot.skip(ftype)
11412 
      iprot.readFieldEnd()
11413 
    iprot.readStructEnd()
11414 
 
11415 
  def write(self, oprot):
11416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11418 
      return
11419 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11420 
    if self.cart is not None:
11421 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11422 
      self.cart.write(oprot)
1976 varun.gupt 11423 
      oprot.writeFieldEnd()
3431 rajveer 11424 
    if self.couponCode is not None:
1976 varun.gupt 11425 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11426 
      oprot.writeString(self.couponCode)
11427 
      oprot.writeFieldEnd()
11428 
    oprot.writeFieldStop()
11429 
    oprot.writeStructEnd()
11430 
 
3431 rajveer 11431 
  def validate(self):
11432 
    return
11433 
 
11434 
 
1976 varun.gupt 11435 
  def __repr__(self):
11436 
    L = ['%s=%r' % (key, value)
11437 
      for key, value in self.__dict__.iteritems()]
11438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11439 
 
11440 
  def __eq__(self, other):
11441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11442 
 
11443 
  def __ne__(self, other):
11444 
    return not (self == other)
11445 
 
11446 
class applyCouponToCart_result:
11447 
  """
11448 
  Attributes:
11449 
   - scx
11450 
  """
11451 
 
11452 
  thrift_spec = (
11453 
    None, # 0
11454 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11455 
  )
11456 
 
11457 
  def __init__(self, scx=None,):
11458 
    self.scx = scx
11459 
 
11460 
  def read(self, iprot):
11461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11463 
      return
11464 
    iprot.readStructBegin()
11465 
    while True:
11466 
      (fname, ftype, fid) = iprot.readFieldBegin()
11467 
      if ftype == TType.STOP:
11468 
        break
11469 
      if fid == 1:
11470 
        if ftype == TType.STRUCT:
11471 
          self.scx = ShoppingCartException()
11472 
          self.scx.read(iprot)
11473 
        else:
11474 
          iprot.skip(ftype)
11475 
      else:
11476 
        iprot.skip(ftype)
11477 
      iprot.readFieldEnd()
11478 
    iprot.readStructEnd()
11479 
 
11480 
  def write(self, oprot):
11481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11483 
      return
11484 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11485 
    if self.scx is not None:
1976 varun.gupt 11486 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11487 
      self.scx.write(oprot)
11488 
      oprot.writeFieldEnd()
11489 
    oprot.writeFieldStop()
11490 
    oprot.writeStructEnd()
11491 
 
3431 rajveer 11492 
  def validate(self):
11493 
    return
11494 
 
11495 
 
1976 varun.gupt 11496 
  def __repr__(self):
11497 
    L = ['%s=%r' % (key, value)
11498 
      for key, value in self.__dict__.iteritems()]
11499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11500 
 
11501 
  def __eq__(self, other):
11502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11503 
 
11504 
  def __ne__(self, other):
11505 
    return not (self == other)
11506 
 
11507 
class removeCoupon_args:
11508 
  """
11509 
  Attributes:
11510 
   - cartId
11511 
  """
11512 
 
11513 
  thrift_spec = (
11514 
    None, # 0
11515 
    (1, TType.I64, 'cartId', None, None, ), # 1
11516 
  )
11517 
 
11518 
  def __init__(self, cartId=None,):
11519 
    self.cartId = cartId
11520 
 
11521 
  def read(self, iprot):
11522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11524 
      return
11525 
    iprot.readStructBegin()
11526 
    while True:
11527 
      (fname, ftype, fid) = iprot.readFieldBegin()
11528 
      if ftype == TType.STOP:
11529 
        break
11530 
      if fid == 1:
11531 
        if ftype == TType.I64:
11532 
          self.cartId = iprot.readI64();
11533 
        else:
11534 
          iprot.skip(ftype)
11535 
      else:
11536 
        iprot.skip(ftype)
11537 
      iprot.readFieldEnd()
11538 
    iprot.readStructEnd()
11539 
 
11540 
  def write(self, oprot):
11541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11543 
      return
11544 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11545 
    if self.cartId is not None:
1976 varun.gupt 11546 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11547 
      oprot.writeI64(self.cartId)
11548 
      oprot.writeFieldEnd()
11549 
    oprot.writeFieldStop()
11550 
    oprot.writeStructEnd()
11551 
 
3431 rajveer 11552 
  def validate(self):
11553 
    return
11554 
 
11555 
 
1976 varun.gupt 11556 
  def __repr__(self):
11557 
    L = ['%s=%r' % (key, value)
11558 
      for key, value in self.__dict__.iteritems()]
11559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11560 
 
11561 
  def __eq__(self, other):
11562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11563 
 
11564 
  def __ne__(self, other):
11565 
    return not (self == other)
11566 
 
11567 
class removeCoupon_result:
11568 
  """
11569 
  Attributes:
11570 
   - scx
11571 
  """
11572 
 
11573 
  thrift_spec = (
11574 
    None, # 0
11575 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11576 
  )
11577 
 
11578 
  def __init__(self, scx=None,):
11579 
    self.scx = scx
11580 
 
11581 
  def read(self, iprot):
11582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11584 
      return
11585 
    iprot.readStructBegin()
11586 
    while True:
11587 
      (fname, ftype, fid) = iprot.readFieldBegin()
11588 
      if ftype == TType.STOP:
11589 
        break
11590 
      if fid == 1:
11591 
        if ftype == TType.STRUCT:
11592 
          self.scx = ShoppingCartException()
11593 
          self.scx.read(iprot)
11594 
        else:
11595 
          iprot.skip(ftype)
11596 
      else:
11597 
        iprot.skip(ftype)
11598 
      iprot.readFieldEnd()
11599 
    iprot.readStructEnd()
11600 
 
11601 
  def write(self, oprot):
11602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11604 
      return
11605 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11606 
    if self.scx is not None:
1976 varun.gupt 11607 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11608 
      self.scx.write(oprot)
11609 
      oprot.writeFieldEnd()
11610 
    oprot.writeFieldStop()
11611 
    oprot.writeStructEnd()
11612 
 
3431 rajveer 11613 
  def validate(self):
11614 
    return
11615 
 
11616 
 
1976 varun.gupt 11617 
  def __repr__(self):
11618 
    L = ['%s=%r' % (key, value)
11619 
      for key, value in self.__dict__.iteritems()]
11620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11621 
 
11622 
  def __eq__(self, other):
11623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11624 
 
11625 
  def __ne__(self, other):
11626 
    return not (self == other)
11627 
 
3554 varun.gupt 11628 
class deleteDiscountsFromCart_args:
11629 
  """
11630 
  Attributes:
11631 
   - cartId
11632 
  """
11633 
 
11634 
  thrift_spec = (
11635 
    None, # 0
11636 
    (1, TType.I64, 'cartId', None, None, ), # 1
11637 
  )
11638 
 
11639 
  def __init__(self, cartId=None,):
11640 
    self.cartId = cartId
11641 
 
11642 
  def read(self, iprot):
11643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11645 
      return
11646 
    iprot.readStructBegin()
11647 
    while True:
11648 
      (fname, ftype, fid) = iprot.readFieldBegin()
11649 
      if ftype == TType.STOP:
11650 
        break
11651 
      if fid == 1:
11652 
        if ftype == TType.I64:
11653 
          self.cartId = iprot.readI64();
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      else:
11657 
        iprot.skip(ftype)
11658 
      iprot.readFieldEnd()
11659 
    iprot.readStructEnd()
11660 
 
11661 
  def write(self, oprot):
11662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11664 
      return
11665 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11666 
    if self.cartId is not None:
11667 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11668 
      oprot.writeI64(self.cartId)
11669 
      oprot.writeFieldEnd()
11670 
    oprot.writeFieldStop()
11671 
    oprot.writeStructEnd()
11672 
 
11673 
  def validate(self):
11674 
    return
11675 
 
11676 
 
11677 
  def __repr__(self):
11678 
    L = ['%s=%r' % (key, value)
11679 
      for key, value in self.__dict__.iteritems()]
11680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11681 
 
11682 
  def __eq__(self, other):
11683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11684 
 
11685 
  def __ne__(self, other):
11686 
    return not (self == other)
11687 
 
11688 
class deleteDiscountsFromCart_result:
11689 
  """
11690 
  Attributes:
11691 
   - scx
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    None, # 0
11696 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11697 
  )
11698 
 
11699 
  def __init__(self, scx=None,):
11700 
    self.scx = scx
11701 
 
11702 
  def read(self, iprot):
11703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11705 
      return
11706 
    iprot.readStructBegin()
11707 
    while True:
11708 
      (fname, ftype, fid) = iprot.readFieldBegin()
11709 
      if ftype == TType.STOP:
11710 
        break
11711 
      if fid == 1:
11712 
        if ftype == TType.STRUCT:
11713 
          self.scx = ShoppingCartException()
11714 
          self.scx.read(iprot)
11715 
        else:
11716 
          iprot.skip(ftype)
11717 
      else:
11718 
        iprot.skip(ftype)
11719 
      iprot.readFieldEnd()
11720 
    iprot.readStructEnd()
11721 
 
11722 
  def write(self, oprot):
11723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11725 
      return
11726 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
11727 
    if self.scx is not None:
11728 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11729 
      self.scx.write(oprot)
11730 
      oprot.writeFieldEnd()
11731 
    oprot.writeFieldStop()
11732 
    oprot.writeStructEnd()
11733 
 
11734 
  def validate(self):
11735 
    return
11736 
 
11737 
 
11738 
  def __repr__(self):
11739 
    L = ['%s=%r' % (key, value)
11740 
      for key, value in self.__dict__.iteritems()]
11741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11742 
 
11743 
  def __eq__(self, other):
11744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11745 
 
11746 
  def __ne__(self, other):
11747 
    return not (self == other)
11748 
 
11749 
class saveDiscounts_args:
11750 
  """
11751 
  Attributes:
11752 
   - discounts
11753 
  """
11754 
 
11755 
  thrift_spec = (
11756 
    None, # 0
11757 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
11758 
  )
11759 
 
11760 
  def __init__(self, discounts=None,):
11761 
    self.discounts = discounts
11762 
 
11763 
  def read(self, iprot):
11764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11766 
      return
11767 
    iprot.readStructBegin()
11768 
    while True:
11769 
      (fname, ftype, fid) = iprot.readFieldBegin()
11770 
      if ftype == TType.STOP:
11771 
        break
11772 
      if fid == 1:
11773 
        if ftype == TType.LIST:
11774 
          self.discounts = []
11592 amit.gupta 11775 
          (_etype163, _size160) = iprot.readListBegin()
11776 
          for _i164 in xrange(_size160):
11777 
            _elem165 = Discount()
11778 
            _elem165.read(iprot)
11779 
            self.discounts.append(_elem165)
3554 varun.gupt 11780 
          iprot.readListEnd()
11781 
        else:
11782 
          iprot.skip(ftype)
11783 
      else:
11784 
        iprot.skip(ftype)
11785 
      iprot.readFieldEnd()
11786 
    iprot.readStructEnd()
11787 
 
11788 
  def write(self, oprot):
11789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11791 
      return
11792 
    oprot.writeStructBegin('saveDiscounts_args')
11793 
    if self.discounts is not None:
11794 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
11795 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 11796 
      for iter166 in self.discounts:
11797 
        iter166.write(oprot)
3554 varun.gupt 11798 
      oprot.writeListEnd()
11799 
      oprot.writeFieldEnd()
11800 
    oprot.writeFieldStop()
11801 
    oprot.writeStructEnd()
11802 
 
11803 
  def validate(self):
11804 
    return
11805 
 
11806 
 
11807 
  def __repr__(self):
11808 
    L = ['%s=%r' % (key, value)
11809 
      for key, value in self.__dict__.iteritems()]
11810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11811 
 
11812 
  def __eq__(self, other):
11813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11814 
 
11815 
  def __ne__(self, other):
11816 
    return not (self == other)
11817 
 
11818 
class saveDiscounts_result:
11819 
  """
11820 
  Attributes:
11821 
   - scx
11822 
  """
11823 
 
11824 
  thrift_spec = (
11825 
    None, # 0
11826 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11827 
  )
11828 
 
11829 
  def __init__(self, scx=None,):
11830 
    self.scx = scx
11831 
 
11832 
  def read(self, iprot):
11833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11835 
      return
11836 
    iprot.readStructBegin()
11837 
    while True:
11838 
      (fname, ftype, fid) = iprot.readFieldBegin()
11839 
      if ftype == TType.STOP:
11840 
        break
11841 
      if fid == 1:
11842 
        if ftype == TType.STRUCT:
11843 
          self.scx = ShoppingCartException()
11844 
          self.scx.read(iprot)
11845 
        else:
11846 
          iprot.skip(ftype)
11847 
      else:
11848 
        iprot.skip(ftype)
11849 
      iprot.readFieldEnd()
11850 
    iprot.readStructEnd()
11851 
 
11852 
  def write(self, oprot):
11853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11855 
      return
11856 
    oprot.writeStructBegin('saveDiscounts_result')
11857 
    if self.scx is not None:
11858 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11859 
      self.scx.write(oprot)
11860 
      oprot.writeFieldEnd()
11861 
    oprot.writeFieldStop()
11862 
    oprot.writeStructEnd()
11863 
 
11864 
  def validate(self):
11865 
    return
11866 
 
11867 
 
11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
690 chandransh 11879 
class createOrders_args:
559 chandransh 11880 
  """
11881 
  Attributes:
11882 
   - cartId
2815 vikas 11883 
   - sessionSource
11884 
   - sessionStartTime
3858 vikas 11885 
   - firstSource
11886 
   - firstSourceTime
5326 rajveer 11887 
   - userId
6389 rajveer 11888 
   - schemeId
11526 amit.gupta 11889 
   - orderSource
559 chandransh 11890 
  """
11891 
 
11892 
  thrift_spec = (
11893 
    None, # 0
11894 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11895 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11896 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 11897 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
11898 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 11899 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 11900 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 11901 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 11902 
  )
11903 
 
11526 amit.gupta 11904 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 11905 
    self.cartId = cartId
2815 vikas 11906 
    self.sessionSource = sessionSource
11907 
    self.sessionStartTime = sessionStartTime
3858 vikas 11908 
    self.firstSource = firstSource
11909 
    self.firstSourceTime = firstSourceTime
5326 rajveer 11910 
    self.userId = userId
6389 rajveer 11911 
    self.schemeId = schemeId
11526 amit.gupta 11912 
    self.orderSource = orderSource
559 chandransh 11913 
 
11914 
  def read(self, iprot):
11915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11917 
      return
11918 
    iprot.readStructBegin()
11919 
    while True:
11920 
      (fname, ftype, fid) = iprot.readFieldBegin()
11921 
      if ftype == TType.STOP:
11922 
        break
11923 
      if fid == 1:
11924 
        if ftype == TType.I64:
11925 
          self.cartId = iprot.readI64();
11926 
        else:
11927 
          iprot.skip(ftype)
2815 vikas 11928 
      elif fid == 2:
11929 
        if ftype == TType.STRING:
11930 
          self.sessionSource = iprot.readString();
11931 
        else:
11932 
          iprot.skip(ftype)
11933 
      elif fid == 3:
11934 
        if ftype == TType.I64:
11935 
          self.sessionStartTime = iprot.readI64();
11936 
        else:
11937 
          iprot.skip(ftype)
3858 vikas 11938 
      elif fid == 4:
11939 
        if ftype == TType.STRING:
11940 
          self.firstSource = iprot.readString();
11941 
        else:
11942 
          iprot.skip(ftype)
11943 
      elif fid == 5:
11944 
        if ftype == TType.I64:
11945 
          self.firstSourceTime = iprot.readI64();
11946 
        else:
11947 
          iprot.skip(ftype)
5326 rajveer 11948 
      elif fid == 6:
11949 
        if ftype == TType.I64:
11950 
          self.userId = iprot.readI64();
11951 
        else:
11952 
          iprot.skip(ftype)
6389 rajveer 11953 
      elif fid == 7:
11954 
        if ftype == TType.I64:
11955 
          self.schemeId = iprot.readI64();
11956 
        else:
11957 
          iprot.skip(ftype)
11526 amit.gupta 11958 
      elif fid == 8:
11959 
        if ftype == TType.I64:
11960 
          self.orderSource = iprot.readI64();
11961 
        else:
11962 
          iprot.skip(ftype)
559 chandransh 11963 
      else:
11964 
        iprot.skip(ftype)
11965 
      iprot.readFieldEnd()
11966 
    iprot.readStructEnd()
11967 
 
11968 
  def write(self, oprot):
11969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11971 
      return
690 chandransh 11972 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 11973 
    if self.cartId is not None:
559 chandransh 11974 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11975 
      oprot.writeI64(self.cartId)
11976 
      oprot.writeFieldEnd()
3431 rajveer 11977 
    if self.sessionSource is not None:
2815 vikas 11978 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11979 
      oprot.writeString(self.sessionSource)
11980 
      oprot.writeFieldEnd()
3431 rajveer 11981 
    if self.sessionStartTime is not None:
2815 vikas 11982 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11983 
      oprot.writeI64(self.sessionStartTime)
11984 
      oprot.writeFieldEnd()
3858 vikas 11985 
    if self.firstSource is not None:
11986 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
11987 
      oprot.writeString(self.firstSource)
11988 
      oprot.writeFieldEnd()
11989 
    if self.firstSourceTime is not None:
11990 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
11991 
      oprot.writeI64(self.firstSourceTime)
11992 
      oprot.writeFieldEnd()
5326 rajveer 11993 
    if self.userId is not None:
11994 
      oprot.writeFieldBegin('userId', TType.I64, 6)
11995 
      oprot.writeI64(self.userId)
11996 
      oprot.writeFieldEnd()
6389 rajveer 11997 
    if self.schemeId is not None:
11998 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
11999 
      oprot.writeI64(self.schemeId)
12000 
      oprot.writeFieldEnd()
11526 amit.gupta 12001 
    if self.orderSource is not None:
12002 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12003 
      oprot.writeI64(self.orderSource)
12004 
      oprot.writeFieldEnd()
559 chandransh 12005 
    oprot.writeFieldStop()
12006 
    oprot.writeStructEnd()
12007 
 
3431 rajveer 12008 
  def validate(self):
12009 
    return
12010 
 
12011 
 
559 chandransh 12012 
  def __repr__(self):
12013 
    L = ['%s=%r' % (key, value)
12014 
      for key, value in self.__dict__.iteritems()]
12015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12016 
 
12017 
  def __eq__(self, other):
12018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12019 
 
12020 
  def __ne__(self, other):
12021 
    return not (self == other)
12022 
 
690 chandransh 12023 
class createOrders_result:
559 chandransh 12024 
  """
12025 
  Attributes:
94 ashish 12026 
   - success
559 chandransh 12027 
   - scx
94 ashish 12028 
  """
12029 
 
12030 
  thrift_spec = (
575 chandransh 12031 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12032 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12033 
  )
12034 
 
559 chandransh 12035 
  def __init__(self, success=None, scx=None,):
94 ashish 12036 
    self.success = success
559 chandransh 12037 
    self.scx = scx
94 ashish 12038 
 
12039 
  def read(self, iprot):
12040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12042 
      return
12043 
    iprot.readStructBegin()
12044 
    while True:
12045 
      (fname, ftype, fid) = iprot.readFieldBegin()
12046 
      if ftype == TType.STOP:
12047 
        break
12048 
      if fid == 0:
575 chandransh 12049 
        if ftype == TType.I64:
12050 
          self.success = iprot.readI64();
94 ashish 12051 
        else:
12052 
          iprot.skip(ftype)
12053 
      elif fid == 1:
12054 
        if ftype == TType.STRUCT:
559 chandransh 12055 
          self.scx = ShoppingCartException()
12056 
          self.scx.read(iprot)
94 ashish 12057 
        else:
12058 
          iprot.skip(ftype)
12059 
      else:
12060 
        iprot.skip(ftype)
12061 
      iprot.readFieldEnd()
12062 
    iprot.readStructEnd()
12063 
 
12064 
  def write(self, oprot):
12065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12067 
      return
690 chandransh 12068 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12069 
    if self.success is not None:
575 chandransh 12070 
      oprot.writeFieldBegin('success', TType.I64, 0)
12071 
      oprot.writeI64(self.success)
94 ashish 12072 
      oprot.writeFieldEnd()
3431 rajveer 12073 
    if self.scx is not None:
559 chandransh 12074 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12075 
      self.scx.write(oprot)
94 ashish 12076 
      oprot.writeFieldEnd()
12077 
    oprot.writeFieldStop()
12078 
    oprot.writeStructEnd()
12079 
 
3431 rajveer 12080 
  def validate(self):
12081 
    return
12082 
 
12083 
 
94 ashish 12084 
  def __repr__(self):
12085 
    L = ['%s=%r' % (key, value)
12086 
      for key, value in self.__dict__.iteritems()]
12087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12088 
 
12089 
  def __eq__(self, other):
12090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12091 
 
12092 
  def __ne__(self, other):
12093 
    return not (self == other)
12094 
 
559 chandransh 12095 
class validateCart_args:
94 ashish 12096 
  """
12097 
  Attributes:
559 chandransh 12098 
   - cartId
3557 rajveer 12099 
   - sourceId
94 ashish 12100 
  """
12101 
 
12102 
  thrift_spec = (
12103 
    None, # 0
559 chandransh 12104 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12105 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12106 
  )
12107 
 
3557 rajveer 12108 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12109 
    self.cartId = cartId
3557 rajveer 12110 
    self.sourceId = sourceId
94 ashish 12111 
 
12112 
  def read(self, iprot):
12113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12115 
      return
12116 
    iprot.readStructBegin()
12117 
    while True:
12118 
      (fname, ftype, fid) = iprot.readFieldBegin()
12119 
      if ftype == TType.STOP:
12120 
        break
12121 
      if fid == 1:
12122 
        if ftype == TType.I64:
559 chandransh 12123 
          self.cartId = iprot.readI64();
94 ashish 12124 
        else:
12125 
          iprot.skip(ftype)
3557 rajveer 12126 
      elif fid == 2:
12127 
        if ftype == TType.I64:
12128 
          self.sourceId = iprot.readI64();
12129 
        else:
12130 
          iprot.skip(ftype)
94 ashish 12131 
      else:
12132 
        iprot.skip(ftype)
12133 
      iprot.readFieldEnd()
12134 
    iprot.readStructEnd()
12135 
 
12136 
  def write(self, oprot):
12137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12139 
      return
559 chandransh 12140 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12141 
    if self.cartId is not None:
559 chandransh 12142 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12143 
      oprot.writeI64(self.cartId)
94 ashish 12144 
      oprot.writeFieldEnd()
3557 rajveer 12145 
    if self.sourceId is not None:
12146 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12147 
      oprot.writeI64(self.sourceId)
12148 
      oprot.writeFieldEnd()
94 ashish 12149 
    oprot.writeFieldStop()
12150 
    oprot.writeStructEnd()
12151 
 
3431 rajveer 12152 
  def validate(self):
12153 
    return
12154 
 
12155 
 
94 ashish 12156 
  def __repr__(self):
12157 
    L = ['%s=%r' % (key, value)
12158 
      for key, value in self.__dict__.iteritems()]
12159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12160 
 
12161 
  def __eq__(self, other):
12162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12163 
 
12164 
  def __ne__(self, other):
12165 
    return not (self == other)
12166 
 
559 chandransh 12167 
class validateCart_result:
94 ashish 12168 
  """
12169 
  Attributes:
12170 
   - success
575 chandransh 12171 
   - scex
94 ashish 12172 
  """
12173 
 
12174 
  thrift_spec = (
6736 amit.gupta 12175 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12176 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12177 
  )
12178 
 
575 chandransh 12179 
  def __init__(self, success=None, scex=None,):
94 ashish 12180 
    self.success = success
575 chandransh 12181 
    self.scex = scex
94 ashish 12182 
 
12183 
  def read(self, iprot):
12184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12186 
      return
12187 
    iprot.readStructBegin()
12188 
    while True:
12189 
      (fname, ftype, fid) = iprot.readFieldBegin()
12190 
      if ftype == TType.STOP:
12191 
        break
12192 
      if fid == 0:
6736 amit.gupta 12193 
        if ftype == TType.LIST:
12194 
          self.success = []
11592 amit.gupta 12195 
          (_etype170, _size167) = iprot.readListBegin()
12196 
          for _i171 in xrange(_size167):
12197 
            _elem172 = iprot.readString();
12198 
            self.success.append(_elem172)
6736 amit.gupta 12199 
          iprot.readListEnd()
94 ashish 12200 
        else:
12201 
          iprot.skip(ftype)
575 chandransh 12202 
      elif fid == 1:
12203 
        if ftype == TType.STRUCT:
12204 
          self.scex = ShoppingCartException()
12205 
          self.scex.read(iprot)
12206 
        else:
12207 
          iprot.skip(ftype)
94 ashish 12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
559 chandransh 12217 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12218 
    if self.success is not None:
6736 amit.gupta 12219 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12220 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12221 
      for iter173 in self.success:
12222 
        oprot.writeString(iter173)
6736 amit.gupta 12223 
      oprot.writeListEnd()
94 ashish 12224 
      oprot.writeFieldEnd()
3431 rajveer 12225 
    if self.scex is not None:
575 chandransh 12226 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12227 
      self.scex.write(oprot)
12228 
      oprot.writeFieldEnd()
559 chandransh 12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
3431 rajveer 12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
559 chandransh 12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
11980 amit.gupta 12247 
class validateCartWithDealerCoupon_args:
12248 
  """
12249 
  Attributes:
12250 
   - cartId
12251 
   - sourceId
12252 
   - dealCoupon
12253 
  """
12254 
 
12255 
  thrift_spec = (
12256 
    None, # 0
12257 
    (1, TType.I64, 'cartId', None, None, ), # 1
12258 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12259 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12260 
  )
12261 
 
12262 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12263 
    self.cartId = cartId
12264 
    self.sourceId = sourceId
12265 
    self.dealCoupon = dealCoupon
12266 
 
12267 
  def read(self, iprot):
12268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12270 
      return
12271 
    iprot.readStructBegin()
12272 
    while True:
12273 
      (fname, ftype, fid) = iprot.readFieldBegin()
12274 
      if ftype == TType.STOP:
12275 
        break
12276 
      if fid == 1:
12277 
        if ftype == TType.I64:
12278 
          self.cartId = iprot.readI64();
12279 
        else:
12280 
          iprot.skip(ftype)
12281 
      elif fid == 2:
12282 
        if ftype == TType.I64:
12283 
          self.sourceId = iprot.readI64();
12284 
        else:
12285 
          iprot.skip(ftype)
12286 
      elif fid == 3:
12287 
        if ftype == TType.STRING:
12288 
          self.dealCoupon = iprot.readString();
12289 
        else:
12290 
          iprot.skip(ftype)
12291 
      else:
12292 
        iprot.skip(ftype)
12293 
      iprot.readFieldEnd()
12294 
    iprot.readStructEnd()
12295 
 
12296 
  def write(self, oprot):
12297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12299 
      return
12300 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12301 
    if self.cartId is not None:
12302 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12303 
      oprot.writeI64(self.cartId)
12304 
      oprot.writeFieldEnd()
12305 
    if self.sourceId is not None:
12306 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12307 
      oprot.writeI64(self.sourceId)
12308 
      oprot.writeFieldEnd()
12309 
    if self.dealCoupon is not None:
12310 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12311 
      oprot.writeString(self.dealCoupon)
12312 
      oprot.writeFieldEnd()
12313 
    oprot.writeFieldStop()
12314 
    oprot.writeStructEnd()
12315 
 
12316 
  def validate(self):
12317 
    return
12318 
 
12319 
 
12320 
  def __repr__(self):
12321 
    L = ['%s=%r' % (key, value)
12322 
      for key, value in self.__dict__.iteritems()]
12323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12324 
 
12325 
  def __eq__(self, other):
12326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12327 
 
12328 
  def __ne__(self, other):
12329 
    return not (self == other)
12330 
 
12331 
class validateCartWithDealerCoupon_result:
12332 
  """
12333 
  Attributes:
12334 
   - success
12335 
   - scex
12336 
  """
12337 
 
12338 
  thrift_spec = (
12339 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12340 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12341 
  )
12342 
 
12343 
  def __init__(self, success=None, scex=None,):
12344 
    self.success = success
12345 
    self.scex = scex
12346 
 
12347 
  def read(self, iprot):
12348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12350 
      return
12351 
    iprot.readStructBegin()
12352 
    while True:
12353 
      (fname, ftype, fid) = iprot.readFieldBegin()
12354 
      if ftype == TType.STOP:
12355 
        break
12356 
      if fid == 0:
12357 
        if ftype == TType.LIST:
12358 
          self.success = []
12359 
          (_etype177, _size174) = iprot.readListBegin()
12360 
          for _i178 in xrange(_size174):
12361 
            _elem179 = iprot.readString();
12362 
            self.success.append(_elem179)
12363 
          iprot.readListEnd()
12364 
        else:
12365 
          iprot.skip(ftype)
12366 
      elif fid == 1:
12367 
        if ftype == TType.STRUCT:
12368 
          self.scex = ShoppingCartException()
12369 
          self.scex.read(iprot)
12370 
        else:
12371 
          iprot.skip(ftype)
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
12381 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12382 
    if self.success is not None:
12383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12384 
      oprot.writeListBegin(TType.STRING, len(self.success))
12385 
      for iter180 in self.success:
12386 
        oprot.writeString(iter180)
12387 
      oprot.writeListEnd()
12388 
      oprot.writeFieldEnd()
12389 
    if self.scex is not None:
12390 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12391 
      self.scex.write(oprot)
12392 
      oprot.writeFieldEnd()
12393 
    oprot.writeFieldStop()
12394 
    oprot.writeStructEnd()
12395 
 
12396 
  def validate(self):
12397 
    return
12398 
 
12399 
 
12400 
  def __repr__(self):
12401 
    L = ['%s=%r' % (key, value)
12402 
      for key, value in self.__dict__.iteritems()]
12403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12404 
 
12405 
  def __eq__(self, other):
12406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12407 
 
12408 
  def __ne__(self, other):
12409 
    return not (self == other)
12410 
 
690 chandransh 12411 
class mergeCart_args:
575 chandransh 12412 
  """
12413 
  Attributes:
690 chandransh 12414 
   - fromCartId
12415 
   - toCartId
12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    None, # 0
12420 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12421 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12422 
  )
12423 
 
12424 
  def __init__(self, fromCartId=None, toCartId=None,):
12425 
    self.fromCartId = fromCartId
12426 
    self.toCartId = toCartId
12427 
 
12428 
  def read(self, iprot):
12429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12431 
      return
12432 
    iprot.readStructBegin()
12433 
    while True:
12434 
      (fname, ftype, fid) = iprot.readFieldBegin()
12435 
      if ftype == TType.STOP:
12436 
        break
12437 
      if fid == 1:
12438 
        if ftype == TType.I64:
12439 
          self.fromCartId = iprot.readI64();
12440 
        else:
12441 
          iprot.skip(ftype)
12442 
      elif fid == 2:
12443 
        if ftype == TType.I64:
12444 
          self.toCartId = iprot.readI64();
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
12456 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12457 
    if self.fromCartId is not None:
690 chandransh 12458 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12459 
      oprot.writeI64(self.fromCartId)
12460 
      oprot.writeFieldEnd()
3431 rajveer 12461 
    if self.toCartId is not None:
690 chandransh 12462 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12463 
      oprot.writeI64(self.toCartId)
12464 
      oprot.writeFieldEnd()
12465 
    oprot.writeFieldStop()
12466 
    oprot.writeStructEnd()
12467 
 
3431 rajveer 12468 
  def validate(self):
12469 
    return
12470 
 
12471 
 
690 chandransh 12472 
  def __repr__(self):
12473 
    L = ['%s=%r' % (key, value)
12474 
      for key, value in self.__dict__.iteritems()]
12475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12476 
 
12477 
  def __eq__(self, other):
12478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12479 
 
12480 
  def __ne__(self, other):
12481 
    return not (self == other)
12482 
 
12483 
class mergeCart_result:
12484 
 
12485 
  thrift_spec = (
12486 
  )
12487 
 
12488 
  def read(self, iprot):
12489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12491 
      return
12492 
    iprot.readStructBegin()
12493 
    while True:
12494 
      (fname, ftype, fid) = iprot.readFieldBegin()
12495 
      if ftype == TType.STOP:
12496 
        break
12497 
      else:
12498 
        iprot.skip(ftype)
12499 
      iprot.readFieldEnd()
12500 
    iprot.readStructEnd()
12501 
 
12502 
  def write(self, oprot):
12503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12505 
      return
12506 
    oprot.writeStructBegin('mergeCart_result')
12507 
    oprot.writeFieldStop()
12508 
    oprot.writeStructEnd()
12509 
 
3431 rajveer 12510 
  def validate(self):
12511 
    return
12512 
 
12513 
 
690 chandransh 12514 
  def __repr__(self):
12515 
    L = ['%s=%r' % (key, value)
12516 
      for key, value in self.__dict__.iteritems()]
12517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12518 
 
12519 
  def __eq__(self, other):
12520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12521 
 
12522 
  def __ne__(self, other):
12523 
    return not (self == other)
12524 
 
12525 
class checkOut_args:
12526 
  """
12527 
  Attributes:
575 chandransh 12528 
   - cartId
12529 
  """
12530 
 
12531 
  thrift_spec = (
12532 
    None, # 0
12533 
    (1, TType.I64, 'cartId', None, None, ), # 1
12534 
  )
12535 
 
12536 
  def __init__(self, cartId=None,):
12537 
    self.cartId = cartId
12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 1:
12549 
        if ftype == TType.I64:
12550 
          self.cartId = iprot.readI64();
12551 
        else:
12552 
          iprot.skip(ftype)
12553 
      else:
12554 
        iprot.skip(ftype)
12555 
      iprot.readFieldEnd()
12556 
    iprot.readStructEnd()
12557 
 
12558 
  def write(self, oprot):
12559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12561 
      return
690 chandransh 12562 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12563 
    if self.cartId is not None:
575 chandransh 12564 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12565 
      oprot.writeI64(self.cartId)
12566 
      oprot.writeFieldEnd()
12567 
    oprot.writeFieldStop()
12568 
    oprot.writeStructEnd()
12569 
 
3431 rajveer 12570 
  def validate(self):
12571 
    return
12572 
 
12573 
 
575 chandransh 12574 
  def __repr__(self):
12575 
    L = ['%s=%r' % (key, value)
12576 
      for key, value in self.__dict__.iteritems()]
12577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12578 
 
12579 
  def __eq__(self, other):
12580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12581 
 
12582 
  def __ne__(self, other):
12583 
    return not (self == other)
12584 
 
690 chandransh 12585 
class checkOut_result:
575 chandransh 12586 
  """
12587 
  Attributes:
12588 
   - success
12589 
   - scex
12590 
  """
12591 
 
12592 
  thrift_spec = (
12593 
    (0, TType.BOOL, 'success', None, None, ), # 0
12594 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12595 
  )
12596 
 
12597 
  def __init__(self, success=None, scex=None,):
12598 
    self.success = success
12599 
    self.scex = scex
12600 
 
12601 
  def read(self, iprot):
12602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12604 
      return
12605 
    iprot.readStructBegin()
12606 
    while True:
12607 
      (fname, ftype, fid) = iprot.readFieldBegin()
12608 
      if ftype == TType.STOP:
12609 
        break
12610 
      if fid == 0:
12611 
        if ftype == TType.BOOL:
12612 
          self.success = iprot.readBool();
12613 
        else:
12614 
          iprot.skip(ftype)
12615 
      elif fid == 1:
12616 
        if ftype == TType.STRUCT:
12617 
          self.scex = ShoppingCartException()
12618 
          self.scex.read(iprot)
12619 
        else:
12620 
          iprot.skip(ftype)
12621 
      else:
12622 
        iprot.skip(ftype)
12623 
      iprot.readFieldEnd()
12624 
    iprot.readStructEnd()
12625 
 
12626 
  def write(self, oprot):
12627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12629 
      return
690 chandransh 12630 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12631 
    if self.success is not None:
575 chandransh 12632 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12633 
      oprot.writeBool(self.success)
12634 
      oprot.writeFieldEnd()
3431 rajveer 12635 
    if self.scex is not None:
575 chandransh 12636 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12637 
      self.scex.write(oprot)
12638 
      oprot.writeFieldEnd()
12639 
    oprot.writeFieldStop()
12640 
    oprot.writeStructEnd()
12641 
 
3431 rajveer 12642 
  def validate(self):
12643 
    return
12644 
 
12645 
 
575 chandransh 12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
12656 
 
690 chandransh 12657 
class resetCart_args:
559 chandransh 12658 
  """
12659 
  Attributes:
690 chandransh 12660 
   - cartId
12661 
   - items
559 chandransh 12662 
  """
12663 
 
12664 
  thrift_spec = (
12665 
    None, # 0
690 chandransh 12666 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12667 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12668 
  )
12669 
 
690 chandransh 12670 
  def __init__(self, cartId=None, items=None,):
12671 
    self.cartId = cartId
12672 
    self.items = items
559 chandransh 12673 
 
12674 
  def read(self, iprot):
12675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12677 
      return
12678 
    iprot.readStructBegin()
12679 
    while True:
12680 
      (fname, ftype, fid) = iprot.readFieldBegin()
12681 
      if ftype == TType.STOP:
12682 
        break
12683 
      if fid == 1:
12684 
        if ftype == TType.I64:
690 chandransh 12685 
          self.cartId = iprot.readI64();
559 chandransh 12686 
        else:
12687 
          iprot.skip(ftype)
12688 
      elif fid == 2:
690 chandransh 12689 
        if ftype == TType.MAP:
12690 
          self.items = {}
11980 amit.gupta 12691 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12692 
          for _i185 in xrange(_size181):
12693 
            _key186 = iprot.readI64();
12694 
            _val187 = iprot.readDouble();
12695 
            self.items[_key186] = _val187
690 chandransh 12696 
          iprot.readMapEnd()
559 chandransh 12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      else:
12700 
        iprot.skip(ftype)
12701 
      iprot.readFieldEnd()
12702 
    iprot.readStructEnd()
12703 
 
12704 
  def write(self, oprot):
12705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12707 
      return
690 chandransh 12708 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 12709 
    if self.cartId is not None:
690 chandransh 12710 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12711 
      oprot.writeI64(self.cartId)
94 ashish 12712 
      oprot.writeFieldEnd()
3431 rajveer 12713 
    if self.items is not None:
690 chandransh 12714 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 12715 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 12716 
      for kiter188,viter189 in self.items.items():
12717 
        oprot.writeI64(kiter188)
12718 
        oprot.writeDouble(viter189)
690 chandransh 12719 
      oprot.writeMapEnd()
559 chandransh 12720 
      oprot.writeFieldEnd()
94 ashish 12721 
    oprot.writeFieldStop()
12722 
    oprot.writeStructEnd()
12723 
 
3431 rajveer 12724 
  def validate(self):
12725 
    return
12726 
 
12727 
 
94 ashish 12728 
  def __repr__(self):
12729 
    L = ['%s=%r' % (key, value)
12730 
      for key, value in self.__dict__.iteritems()]
12731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12732 
 
12733 
  def __eq__(self, other):
12734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12735 
 
12736 
  def __ne__(self, other):
12737 
    return not (self == other)
12738 
 
690 chandransh 12739 
class resetCart_result:
12740 
  """
12741 
  Attributes:
12742 
   - success
12743 
   - scex
12744 
  """
559 chandransh 12745 
 
12746 
  thrift_spec = (
690 chandransh 12747 
    (0, TType.BOOL, 'success', None, None, ), # 0
12748 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 12749 
  )
12750 
 
690 chandransh 12751 
  def __init__(self, success=None, scex=None,):
12752 
    self.success = success
12753 
    self.scex = scex
12754 
 
559 chandransh 12755 
  def read(self, iprot):
12756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12758 
      return
12759 
    iprot.readStructBegin()
12760 
    while True:
12761 
      (fname, ftype, fid) = iprot.readFieldBegin()
12762 
      if ftype == TType.STOP:
12763 
        break
690 chandransh 12764 
      if fid == 0:
12765 
        if ftype == TType.BOOL:
12766 
          self.success = iprot.readBool();
12767 
        else:
12768 
          iprot.skip(ftype)
12769 
      elif fid == 1:
12770 
        if ftype == TType.STRUCT:
12771 
          self.scex = ShoppingCartException()
12772 
          self.scex.read(iprot)
12773 
        else:
12774 
          iprot.skip(ftype)
559 chandransh 12775 
      else:
12776 
        iprot.skip(ftype)
12777 
      iprot.readFieldEnd()
12778 
    iprot.readStructEnd()
12779 
 
12780 
  def write(self, oprot):
12781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12783 
      return
690 chandransh 12784 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 12785 
    if self.success is not None:
690 chandransh 12786 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12787 
      oprot.writeBool(self.success)
12788 
      oprot.writeFieldEnd()
3431 rajveer 12789 
    if self.scex is not None:
690 chandransh 12790 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12791 
      self.scex.write(oprot)
12792 
      oprot.writeFieldEnd()
559 chandransh 12793 
    oprot.writeFieldStop()
12794 
    oprot.writeStructEnd()
12795 
 
3431 rajveer 12796 
  def validate(self):
12797 
    return
12798 
 
12799 
 
559 chandransh 12800 
  def __repr__(self):
12801 
    L = ['%s=%r' % (key, value)
12802 
      for key, value in self.__dict__.iteritems()]
12803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12804 
 
12805 
  def __eq__(self, other):
12806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12807 
 
12808 
  def __ne__(self, other):
12809 
    return not (self == other)
12810 
 
2981 rajveer 12811 
class getUserCount_args:
94 ashish 12812 
  """
12813 
  Attributes:
2981 rajveer 12814 
   - userType
559 chandransh 12815 
  """
12816 
 
12817 
  thrift_spec = (
12818 
    None, # 0
2981 rajveer 12819 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 12820 
  )
12821 
 
2981 rajveer 12822 
  def __init__(self, userType=None,):
12823 
    self.userType = userType
559 chandransh 12824 
 
12825 
  def read(self, iprot):
12826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12828 
      return
12829 
    iprot.readStructBegin()
12830 
    while True:
12831 
      (fname, ftype, fid) = iprot.readFieldBegin()
12832 
      if ftype == TType.STOP:
12833 
        break
12834 
      if fid == 1:
2981 rajveer 12835 
        if ftype == TType.I32:
12836 
          self.userType = iprot.readI32();
559 chandransh 12837 
        else:
12838 
          iprot.skip(ftype)
12839 
      else:
12840 
        iprot.skip(ftype)
12841 
      iprot.readFieldEnd()
12842 
    iprot.readStructEnd()
12843 
 
12844 
  def write(self, oprot):
12845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12847 
      return
2981 rajveer 12848 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 12849 
    if self.userType is not None:
2981 rajveer 12850 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12851 
      oprot.writeI32(self.userType)
559 chandransh 12852 
      oprot.writeFieldEnd()
12853 
    oprot.writeFieldStop()
12854 
    oprot.writeStructEnd()
12855 
 
3431 rajveer 12856 
  def validate(self):
12857 
    return
12858 
 
12859 
 
559 chandransh 12860 
  def __repr__(self):
12861 
    L = ['%s=%r' % (key, value)
12862 
      for key, value in self.__dict__.iteritems()]
12863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12864 
 
12865 
  def __eq__(self, other):
12866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12867 
 
12868 
  def __ne__(self, other):
12869 
    return not (self == other)
12870 
 
2981 rajveer 12871 
class getUserCount_result:
94 ashish 12872 
  """
12873 
  Attributes:
12874 
   - success
12875 
  """
12876 
 
12877 
  thrift_spec = (
2981 rajveer 12878 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12879 
  )
12880 
 
2981 rajveer 12881 
  def __init__(self, success=None,):
94 ashish 12882 
    self.success = success
12883 
 
12884 
  def read(self, iprot):
12885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12887 
      return
12888 
    iprot.readStructBegin()
12889 
    while True:
12890 
      (fname, ftype, fid) = iprot.readFieldBegin()
12891 
      if ftype == TType.STOP:
12892 
        break
12893 
      if fid == 0:
2981 rajveer 12894 
        if ftype == TType.I64:
12895 
          self.success = iprot.readI64();
94 ashish 12896 
        else:
12897 
          iprot.skip(ftype)
12898 
      else:
12899 
        iprot.skip(ftype)
12900 
      iprot.readFieldEnd()
12901 
    iprot.readStructEnd()
12902 
 
12903 
  def write(self, oprot):
12904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12906 
      return
2981 rajveer 12907 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 12908 
    if self.success is not None:
2981 rajveer 12909 
      oprot.writeFieldBegin('success', TType.I64, 0)
12910 
      oprot.writeI64(self.success)
94 ashish 12911 
      oprot.writeFieldEnd()
12912 
    oprot.writeFieldStop()
12913 
    oprot.writeStructEnd()
12914 
 
3431 rajveer 12915 
  def validate(self):
12916 
    return
12917 
 
12918 
 
94 ashish 12919 
  def __repr__(self):
12920 
    L = ['%s=%r' % (key, value)
12921 
      for key, value in self.__dict__.iteritems()]
12922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12923 
 
12924 
  def __eq__(self, other):
12925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12926 
 
12927 
  def __ne__(self, other):
12928 
    return not (self == other)
12929 
 
2981 rajveer 12930 
class getAllUsers_args:
94 ashish 12931 
  """
12932 
  Attributes:
2981 rajveer 12933 
   - userType
12934 
   - startDate
12935 
   - endDate
94 ashish 12936 
  """
12937 
 
12938 
  thrift_spec = (
12939 
    None, # 0
2981 rajveer 12940 
    (1, TType.I32, 'userType', None, None, ), # 1
12941 
    (2, TType.I64, 'startDate', None, None, ), # 2
12942 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 12943 
  )
12944 
 
2981 rajveer 12945 
  def __init__(self, userType=None, startDate=None, endDate=None,):
12946 
    self.userType = userType
12947 
    self.startDate = startDate
12948 
    self.endDate = endDate
94 ashish 12949 
 
12950 
  def read(self, iprot):
12951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12953 
      return
12954 
    iprot.readStructBegin()
12955 
    while True:
12956 
      (fname, ftype, fid) = iprot.readFieldBegin()
12957 
      if ftype == TType.STOP:
12958 
        break
12959 
      if fid == 1:
2981 rajveer 12960 
        if ftype == TType.I32:
12961 
          self.userType = iprot.readI32();
94 ashish 12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      elif fid == 2:
559 chandransh 12965 
        if ftype == TType.I64:
2981 rajveer 12966 
          self.startDate = iprot.readI64();
94 ashish 12967 
        else:
12968 
          iprot.skip(ftype)
2981 rajveer 12969 
      elif fid == 3:
12970 
        if ftype == TType.I64:
12971 
          self.endDate = iprot.readI64();
12972 
        else:
12973 
          iprot.skip(ftype)
94 ashish 12974 
      else:
12975 
        iprot.skip(ftype)
12976 
      iprot.readFieldEnd()
12977 
    iprot.readStructEnd()
12978 
 
12979 
  def write(self, oprot):
12980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12982 
      return
2981 rajveer 12983 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 12984 
    if self.userType is not None:
2981 rajveer 12985 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12986 
      oprot.writeI32(self.userType)
94 ashish 12987 
      oprot.writeFieldEnd()
3431 rajveer 12988 
    if self.startDate is not None:
2981 rajveer 12989 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12990 
      oprot.writeI64(self.startDate)
94 ashish 12991 
      oprot.writeFieldEnd()
3431 rajveer 12992 
    if self.endDate is not None:
2981 rajveer 12993 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12994 
      oprot.writeI64(self.endDate)
12995 
      oprot.writeFieldEnd()
94 ashish 12996 
    oprot.writeFieldStop()
12997 
    oprot.writeStructEnd()
12998 
 
3431 rajveer 12999 
  def validate(self):
13000 
    return
13001 
 
13002 
 
94 ashish 13003 
  def __repr__(self):
13004 
    L = ['%s=%r' % (key, value)
13005 
      for key, value in self.__dict__.iteritems()]
13006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13007 
 
13008 
  def __eq__(self, other):
13009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13010 
 
13011 
  def __ne__(self, other):
13012 
    return not (self == other)
13013 
 
2981 rajveer 13014 
class getAllUsers_result:
94 ashish 13015 
  """
13016 
  Attributes:
13017 
   - success
13018 
  """
13019 
 
13020 
  thrift_spec = (
2981 rajveer 13021 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13022 
  )
13023 
 
2981 rajveer 13024 
  def __init__(self, success=None,):
94 ashish 13025 
    self.success = success
13026 
 
13027 
  def read(self, iprot):
13028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13030 
      return
13031 
    iprot.readStructBegin()
13032 
    while True:
13033 
      (fname, ftype, fid) = iprot.readFieldBegin()
13034 
      if ftype == TType.STOP:
13035 
        break
13036 
      if fid == 0:
2981 rajveer 13037 
        if ftype == TType.LIST:
13038 
          self.success = []
11980 amit.gupta 13039 
          (_etype193, _size190) = iprot.readListBegin()
13040 
          for _i194 in xrange(_size190):
13041 
            _elem195 = User()
13042 
            _elem195.read(iprot)
13043 
            self.success.append(_elem195)
2981 rajveer 13044 
          iprot.readListEnd()
94 ashish 13045 
        else:
13046 
          iprot.skip(ftype)
13047 
      else:
13048 
        iprot.skip(ftype)
13049 
      iprot.readFieldEnd()
13050 
    iprot.readStructEnd()
13051 
 
13052 
  def write(self, oprot):
13053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13055 
      return
2981 rajveer 13056 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13057 
    if self.success is not None:
2981 rajveer 13058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13060 
      for iter196 in self.success:
13061 
        iter196.write(oprot)
2981 rajveer 13062 
      oprot.writeListEnd()
94 ashish 13063 
      oprot.writeFieldEnd()
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 
 
2981 rajveer 13082 
class getMyResearchItems_args:
559 chandransh 13083 
  """
13084 
  Attributes:
772 rajveer 13085 
   - userId
559 chandransh 13086 
  """
13087 
 
13088 
  thrift_spec = (
13089 
    None, # 0
772 rajveer 13090 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13091 
  )
13092 
 
772 rajveer 13093 
  def __init__(self, userId=None,):
13094 
    self.userId = userId
559 chandransh 13095 
 
13096 
  def read(self, iprot):
13097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13099 
      return
13100 
    iprot.readStructBegin()
13101 
    while True:
13102 
      (fname, ftype, fid) = iprot.readFieldBegin()
13103 
      if ftype == TType.STOP:
13104 
        break
13105 
      if fid == 1:
13106 
        if ftype == TType.I64:
772 rajveer 13107 
          self.userId = iprot.readI64();
559 chandransh 13108 
        else:
13109 
          iprot.skip(ftype)
13110 
      else:
13111 
        iprot.skip(ftype)
13112 
      iprot.readFieldEnd()
13113 
    iprot.readStructEnd()
13114 
 
13115 
  def write(self, oprot):
13116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13118 
      return
2981 rajveer 13119 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13120 
    if self.userId is not None:
772 rajveer 13121 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13122 
      oprot.writeI64(self.userId)
559 chandransh 13123 
      oprot.writeFieldEnd()
13124 
    oprot.writeFieldStop()
13125 
    oprot.writeStructEnd()
13126 
 
3431 rajveer 13127 
  def validate(self):
13128 
    return
13129 
 
13130 
 
559 chandransh 13131 
  def __repr__(self):
13132 
    L = ['%s=%r' % (key, value)
13133 
      for key, value in self.__dict__.iteritems()]
13134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13135 
 
13136 
  def __eq__(self, other):
13137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13138 
 
13139 
  def __ne__(self, other):
13140 
    return not (self == other)
13141 
 
2981 rajveer 13142 
class getMyResearchItems_result:
559 chandransh 13143 
  """
13144 
  Attributes:
130 ashish 13145 
   - success
559 chandransh 13146 
   - scx
130 ashish 13147 
  """
13148 
 
13149 
  thrift_spec = (
2981 rajveer 13150 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13151 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13152 
  )
13153 
 
559 chandransh 13154 
  def __init__(self, success=None, scx=None,):
130 ashish 13155 
    self.success = success
559 chandransh 13156 
    self.scx = scx
130 ashish 13157 
 
13158 
  def read(self, iprot):
13159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13161 
      return
13162 
    iprot.readStructBegin()
13163 
    while True:
13164 
      (fname, ftype, fid) = iprot.readFieldBegin()
13165 
      if ftype == TType.STOP:
13166 
        break
13167 
      if fid == 0:
2981 rajveer 13168 
        if ftype == TType.LIST:
13169 
          self.success = []
11980 amit.gupta 13170 
          (_etype200, _size197) = iprot.readListBegin()
13171 
          for _i201 in xrange(_size197):
13172 
            _elem202 = iprot.readI64();
13173 
            self.success.append(_elem202)
2981 rajveer 13174 
          iprot.readListEnd()
130 ashish 13175 
        else:
13176 
          iprot.skip(ftype)
13177 
      elif fid == 1:
13178 
        if ftype == TType.STRUCT:
559 chandransh 13179 
          self.scx = WidgetException()
13180 
          self.scx.read(iprot)
130 ashish 13181 
        else:
13182 
          iprot.skip(ftype)
13183 
      else:
13184 
        iprot.skip(ftype)
13185 
      iprot.readFieldEnd()
13186 
    iprot.readStructEnd()
13187 
 
13188 
  def write(self, oprot):
13189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13191 
      return
2981 rajveer 13192 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13193 
    if self.success is not None:
2981 rajveer 13194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13195 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13196 
      for iter203 in self.success:
13197 
        oprot.writeI64(iter203)
2981 rajveer 13198 
      oprot.writeListEnd()
130 ashish 13199 
      oprot.writeFieldEnd()
3431 rajveer 13200 
    if self.scx is not None:
559 chandransh 13201 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13202 
      self.scx.write(oprot)
130 ashish 13203 
      oprot.writeFieldEnd()
13204 
    oprot.writeFieldStop()
13205 
    oprot.writeStructEnd()
13206 
 
3431 rajveer 13207 
  def validate(self):
13208 
    return
13209 
 
13210 
 
130 ashish 13211 
  def __repr__(self):
13212 
    L = ['%s=%r' % (key, value)
13213 
      for key, value in self.__dict__.iteritems()]
13214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13215 
 
13216 
  def __eq__(self, other):
13217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13218 
 
13219 
  def __ne__(self, other):
13220 
    return not (self == other)
13221 
 
2981 rajveer 13222 
class updateMyResearch_args:
130 ashish 13223 
  """
13224 
  Attributes:
2981 rajveer 13225 
   - userId
13226 
   - itemId
130 ashish 13227 
  """
13228 
 
13229 
  thrift_spec = (
13230 
    None, # 0
2981 rajveer 13231 
    (1, TType.I64, 'userId', None, None, ), # 1
13232 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13233 
  )
13234 
 
2981 rajveer 13235 
  def __init__(self, userId=None, itemId=None,):
13236 
    self.userId = userId
13237 
    self.itemId = itemId
130 ashish 13238 
 
13239 
  def read(self, iprot):
13240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13242 
      return
13243 
    iprot.readStructBegin()
13244 
    while True:
13245 
      (fname, ftype, fid) = iprot.readFieldBegin()
13246 
      if ftype == TType.STOP:
13247 
        break
13248 
      if fid == 1:
559 chandransh 13249 
        if ftype == TType.I64:
2981 rajveer 13250 
          self.userId = iprot.readI64();
130 ashish 13251 
        else:
13252 
          iprot.skip(ftype)
13253 
      elif fid == 2:
559 chandransh 13254 
        if ftype == TType.I64:
2981 rajveer 13255 
          self.itemId = iprot.readI64();
559 chandransh 13256 
        else:
13257 
          iprot.skip(ftype)
130 ashish 13258 
      else:
13259 
        iprot.skip(ftype)
13260 
      iprot.readFieldEnd()
13261 
    iprot.readStructEnd()
13262 
 
13263 
  def write(self, oprot):
13264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13266 
      return
2981 rajveer 13267 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13268 
    if self.userId is not None:
2981 rajveer 13269 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13270 
      oprot.writeI64(self.userId)
130 ashish 13271 
      oprot.writeFieldEnd()
3431 rajveer 13272 
    if self.itemId is not None:
2981 rajveer 13273 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13274 
      oprot.writeI64(self.itemId)
130 ashish 13275 
      oprot.writeFieldEnd()
13276 
    oprot.writeFieldStop()
13277 
    oprot.writeStructEnd()
13278 
 
3431 rajveer 13279 
  def validate(self):
13280 
    return
13281 
 
13282 
 
130 ashish 13283 
  def __repr__(self):
13284 
    L = ['%s=%r' % (key, value)
13285 
      for key, value in self.__dict__.iteritems()]
13286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13287 
 
13288 
  def __eq__(self, other):
13289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13290 
 
13291 
  def __ne__(self, other):
13292 
    return not (self == other)
13293 
 
2981 rajveer 13294 
class updateMyResearch_result:
13295 
  """
13296 
  Attributes:
13297 
   - success
13298 
   - scx
13299 
  """
559 chandransh 13300 
 
13301 
  thrift_spec = (
2981 rajveer 13302 
    (0, TType.BOOL, 'success', None, None, ), # 0
13303 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13304 
  )
13305 
 
2981 rajveer 13306 
  def __init__(self, success=None, scx=None,):
13307 
    self.success = success
13308 
    self.scx = scx
13309 
 
559 chandransh 13310 
  def read(self, iprot):
13311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13313 
      return
13314 
    iprot.readStructBegin()
13315 
    while True:
13316 
      (fname, ftype, fid) = iprot.readFieldBegin()
13317 
      if ftype == TType.STOP:
13318 
        break
2981 rajveer 13319 
      if fid == 0:
13320 
        if ftype == TType.BOOL:
13321 
          self.success = iprot.readBool();
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      elif fid == 1:
13325 
        if ftype == TType.STRUCT:
13326 
          self.scx = WidgetException()
13327 
          self.scx.read(iprot)
13328 
        else:
13329 
          iprot.skip(ftype)
559 chandransh 13330 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
2981 rajveer 13339 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13340 
    if self.success is not None:
2981 rajveer 13341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13342 
      oprot.writeBool(self.success)
13343 
      oprot.writeFieldEnd()
3431 rajveer 13344 
    if self.scx is not None:
2981 rajveer 13345 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13346 
      self.scx.write(oprot)
13347 
      oprot.writeFieldEnd()
559 chandransh 13348 
    oprot.writeFieldStop()
13349 
    oprot.writeStructEnd()
13350 
 
3431 rajveer 13351 
  def validate(self):
13352 
    return
13353 
 
13354 
 
559 chandransh 13355 
  def __repr__(self):
13356 
    L = ['%s=%r' % (key, value)
13357 
      for key, value in self.__dict__.iteritems()]
13358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13359 
 
13360 
  def __eq__(self, other):
13361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13362 
 
13363 
  def __ne__(self, other):
13364 
    return not (self == other)
13365 
 
2981 rajveer 13366 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13367 
  """
13368 
  Attributes:
2981 rajveer 13369 
   - userId
13370 
   - itemId
1596 ankur.sing 13371 
  """
559 chandransh 13372 
 
1596 ankur.sing 13373 
  thrift_spec = (
13374 
    None, # 0
2981 rajveer 13375 
    (1, TType.I64, 'userId', None, None, ), # 1
13376 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13377 
  )
13378 
 
2981 rajveer 13379 
  def __init__(self, userId=None, itemId=None,):
13380 
    self.userId = userId
13381 
    self.itemId = itemId
1596 ankur.sing 13382 
 
13383 
  def read(self, iprot):
13384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13386 
      return
13387 
    iprot.readStructBegin()
13388 
    while True:
13389 
      (fname, ftype, fid) = iprot.readFieldBegin()
13390 
      if ftype == TType.STOP:
13391 
        break
13392 
      if fid == 1:
2981 rajveer 13393 
        if ftype == TType.I64:
13394 
          self.userId = iprot.readI64();
1596 ankur.sing 13395 
        else:
13396 
          iprot.skip(ftype)
2981 rajveer 13397 
      elif fid == 2:
13398 
        if ftype == TType.I64:
13399 
          self.itemId = iprot.readI64();
13400 
        else:
13401 
          iprot.skip(ftype)
1596 ankur.sing 13402 
      else:
13403 
        iprot.skip(ftype)
13404 
      iprot.readFieldEnd()
13405 
    iprot.readStructEnd()
13406 
 
13407 
  def write(self, oprot):
13408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13410 
      return
2981 rajveer 13411 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13412 
    if self.userId is not None:
2981 rajveer 13413 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13414 
      oprot.writeI64(self.userId)
1596 ankur.sing 13415 
      oprot.writeFieldEnd()
3431 rajveer 13416 
    if self.itemId is not None:
2981 rajveer 13417 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13418 
      oprot.writeI64(self.itemId)
13419 
      oprot.writeFieldEnd()
1596 ankur.sing 13420 
    oprot.writeFieldStop()
13421 
    oprot.writeStructEnd()
13422 
 
3431 rajveer 13423 
  def validate(self):
13424 
    return
13425 
 
13426 
 
1596 ankur.sing 13427 
  def __repr__(self):
13428 
    L = ['%s=%r' % (key, value)
13429 
      for key, value in self.__dict__.iteritems()]
13430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13431 
 
13432 
  def __eq__(self, other):
13433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13434 
 
13435 
  def __ne__(self, other):
13436 
    return not (self == other)
13437 
 
2981 rajveer 13438 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13439 
  """
13440 
  Attributes:
2981 rajveer 13441 
   - scx
1596 ankur.sing 13442 
  """
13443 
 
13444 
  thrift_spec = (
2981 rajveer 13445 
    None, # 0
13446 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13447 
  )
13448 
 
2981 rajveer 13449 
  def __init__(self, scx=None,):
13450 
    self.scx = scx
1596 ankur.sing 13451 
 
13452 
  def read(self, iprot):
13453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13455 
      return
13456 
    iprot.readStructBegin()
13457 
    while True:
13458 
      (fname, ftype, fid) = iprot.readFieldBegin()
13459 
      if ftype == TType.STOP:
13460 
        break
2981 rajveer 13461 
      if fid == 1:
13462 
        if ftype == TType.STRUCT:
13463 
          self.scx = WidgetException()
13464 
          self.scx.read(iprot)
1596 ankur.sing 13465 
        else:
13466 
          iprot.skip(ftype)
13467 
      else:
13468 
        iprot.skip(ftype)
13469 
      iprot.readFieldEnd()
13470 
    iprot.readStructEnd()
13471 
 
13472 
  def write(self, oprot):
13473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13475 
      return
2981 rajveer 13476 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13477 
    if self.scx is not None:
2981 rajveer 13478 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13479 
      self.scx.write(oprot)
1596 ankur.sing 13480 
      oprot.writeFieldEnd()
13481 
    oprot.writeFieldStop()
13482 
    oprot.writeStructEnd()
13483 
 
3431 rajveer 13484 
  def validate(self):
13485 
    return
13486 
 
13487 
 
1596 ankur.sing 13488 
  def __repr__(self):
13489 
    L = ['%s=%r' % (key, value)
13490 
      for key, value in self.__dict__.iteritems()]
13491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13492 
 
13493 
  def __eq__(self, other):
13494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13495 
 
13496 
  def __ne__(self, other):
13497 
    return not (self == other)
13498 
 
2981 rajveer 13499 
class getBrowseHistoryItems_args:
1673 ankur.sing 13500 
  """
13501 
  Attributes:
2981 rajveer 13502 
   - userId
1673 ankur.sing 13503 
  """
1596 ankur.sing 13504 
 
1673 ankur.sing 13505 
  thrift_spec = (
13506 
    None, # 0
2981 rajveer 13507 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13508 
  )
13509 
 
2981 rajveer 13510 
  def __init__(self, userId=None,):
13511 
    self.userId = userId
1673 ankur.sing 13512 
 
13513 
  def read(self, iprot):
13514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13516 
      return
13517 
    iprot.readStructBegin()
13518 
    while True:
13519 
      (fname, ftype, fid) = iprot.readFieldBegin()
13520 
      if ftype == TType.STOP:
13521 
        break
13522 
      if fid == 1:
1891 ankur.sing 13523 
        if ftype == TType.I64:
2981 rajveer 13524 
          self.userId = iprot.readI64();
1891 ankur.sing 13525 
        else:
13526 
          iprot.skip(ftype)
1673 ankur.sing 13527 
      else:
13528 
        iprot.skip(ftype)
13529 
      iprot.readFieldEnd()
13530 
    iprot.readStructEnd()
13531 
 
13532 
  def write(self, oprot):
13533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13535 
      return
2981 rajveer 13536 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13537 
    if self.userId is not None:
2981 rajveer 13538 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13539 
      oprot.writeI64(self.userId)
1673 ankur.sing 13540 
      oprot.writeFieldEnd()
13541 
    oprot.writeFieldStop()
13542 
    oprot.writeStructEnd()
13543 
 
3431 rajveer 13544 
  def validate(self):
13545 
    return
13546 
 
13547 
 
1673 ankur.sing 13548 
  def __repr__(self):
13549 
    L = ['%s=%r' % (key, value)
13550 
      for key, value in self.__dict__.iteritems()]
13551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13552 
 
13553 
  def __eq__(self, other):
13554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13555 
 
13556 
  def __ne__(self, other):
13557 
    return not (self == other)
13558 
 
2981 rajveer 13559 
class getBrowseHistoryItems_result:
1673 ankur.sing 13560 
  """
13561 
  Attributes:
13562 
   - success
2981 rajveer 13563 
   - scx
1673 ankur.sing 13564 
  """
13565 
 
13566 
  thrift_spec = (
2981 rajveer 13567 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13568 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13569 
  )
13570 
 
2981 rajveer 13571 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13572 
    self.success = success
2981 rajveer 13573 
    self.scx = scx
1673 ankur.sing 13574 
 
13575 
  def read(self, iprot):
13576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13578 
      return
13579 
    iprot.readStructBegin()
13580 
    while True:
13581 
      (fname, ftype, fid) = iprot.readFieldBegin()
13582 
      if ftype == TType.STOP:
13583 
        break
13584 
      if fid == 0:
13585 
        if ftype == TType.LIST:
13586 
          self.success = []
11980 amit.gupta 13587 
          (_etype207, _size204) = iprot.readListBegin()
13588 
          for _i208 in xrange(_size204):
13589 
            _elem209 = iprot.readI64();
13590 
            self.success.append(_elem209)
1673 ankur.sing 13591 
          iprot.readListEnd()
13592 
        else:
13593 
          iprot.skip(ftype)
2981 rajveer 13594 
      elif fid == 1:
13595 
        if ftype == TType.STRUCT:
13596 
          self.scx = WidgetException()
13597 
          self.scx.read(iprot)
13598 
        else:
13599 
          iprot.skip(ftype)
1673 ankur.sing 13600 
      else:
13601 
        iprot.skip(ftype)
13602 
      iprot.readFieldEnd()
13603 
    iprot.readStructEnd()
13604 
 
13605 
  def write(self, oprot):
13606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13608 
      return
2981 rajveer 13609 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13610 
    if self.success is not None:
1673 ankur.sing 13611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13612 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13613 
      for iter210 in self.success:
13614 
        oprot.writeI64(iter210)
1673 ankur.sing 13615 
      oprot.writeListEnd()
13616 
      oprot.writeFieldEnd()
3431 rajveer 13617 
    if self.scx is not None:
2981 rajveer 13618 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13619 
      self.scx.write(oprot)
2642 varun.gupt 13620 
      oprot.writeFieldEnd()
13621 
    oprot.writeFieldStop()
13622 
    oprot.writeStructEnd()
13623 
 
3431 rajveer 13624 
  def validate(self):
13625 
    return
13626 
 
13627 
 
2642 varun.gupt 13628 
  def __repr__(self):
13629 
    L = ['%s=%r' % (key, value)
13630 
      for key, value in self.__dict__.iteritems()]
13631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13632 
 
13633 
  def __eq__(self, other):
13634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13635 
 
13636 
  def __ne__(self, other):
13637 
    return not (self == other)
13638 
 
2981 rajveer 13639 
class updateBrowseHistory_args:
2642 varun.gupt 13640 
  """
13641 
  Attributes:
2981 rajveer 13642 
   - userId
13643 
   - itemId
2642 varun.gupt 13644 
  """
13645 
 
13646 
  thrift_spec = (
13647 
    None, # 0
2981 rajveer 13648 
    (1, TType.I64, 'userId', None, None, ), # 1
13649 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13650 
  )
13651 
 
2981 rajveer 13652 
  def __init__(self, userId=None, itemId=None,):
13653 
    self.userId = userId
13654 
    self.itemId = itemId
2642 varun.gupt 13655 
 
13656 
  def read(self, iprot):
13657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13659 
      return
13660 
    iprot.readStructBegin()
13661 
    while True:
13662 
      (fname, ftype, fid) = iprot.readFieldBegin()
13663 
      if ftype == TType.STOP:
13664 
        break
13665 
      if fid == 1:
13666 
        if ftype == TType.I64:
2981 rajveer 13667 
          self.userId = iprot.readI64();
2642 varun.gupt 13668 
        else:
13669 
          iprot.skip(ftype)
13670 
      elif fid == 2:
13671 
        if ftype == TType.I64:
2981 rajveer 13672 
          self.itemId = iprot.readI64();
2642 varun.gupt 13673 
        else:
13674 
          iprot.skip(ftype)
13675 
      else:
13676 
        iprot.skip(ftype)
13677 
      iprot.readFieldEnd()
13678 
    iprot.readStructEnd()
13679 
 
13680 
  def write(self, oprot):
13681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13683 
      return
2981 rajveer 13684 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13685 
    if self.userId is not None:
2981 rajveer 13686 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13687 
      oprot.writeI64(self.userId)
2642 varun.gupt 13688 
      oprot.writeFieldEnd()
3431 rajveer 13689 
    if self.itemId is not None:
2981 rajveer 13690 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13691 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13692 
      oprot.writeFieldEnd()
13693 
    oprot.writeFieldStop()
13694 
    oprot.writeStructEnd()
13695 
 
3431 rajveer 13696 
  def validate(self):
13697 
    return
13698 
 
13699 
 
2642 varun.gupt 13700 
  def __repr__(self):
13701 
    L = ['%s=%r' % (key, value)
13702 
      for key, value in self.__dict__.iteritems()]
13703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13704 
 
13705 
  def __eq__(self, other):
13706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13707 
 
13708 
  def __ne__(self, other):
13709 
    return not (self == other)
13710 
 
2981 rajveer 13711 
class updateBrowseHistory_result:
2642 varun.gupt 13712 
 
13713 
  thrift_spec = (
13714 
  )
13715 
 
13716 
  def read(self, iprot):
13717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13719 
      return
13720 
    iprot.readStructBegin()
13721 
    while True:
13722 
      (fname, ftype, fid) = iprot.readFieldBegin()
13723 
      if ftype == TType.STOP:
13724 
        break
13725 
      else:
13726 
        iprot.skip(ftype)
13727 
      iprot.readFieldEnd()
13728 
    iprot.readStructEnd()
13729 
 
13730 
  def write(self, oprot):
13731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13733 
      return
2981 rajveer 13734 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
3431 rajveer 13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
2642 varun.gupt 13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
3385 varun.gupt 13753 
class getCartsWithCouponCount_args:
13754 
  """
13755 
  Attributes:
13756 
   - couponCode
13757 
  """
2642 varun.gupt 13758 
 
3385 varun.gupt 13759 
  thrift_spec = (
13760 
    None, # 0
13761 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
13762 
  )
13763 
 
13764 
  def __init__(self, couponCode=None,):
13765 
    self.couponCode = couponCode
13766 
 
13767 
  def read(self, iprot):
13768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13770 
      return
13771 
    iprot.readStructBegin()
13772 
    while True:
13773 
      (fname, ftype, fid) = iprot.readFieldBegin()
13774 
      if ftype == TType.STOP:
13775 
        break
13776 
      if fid == 1:
13777 
        if ftype == TType.STRING:
13778 
          self.couponCode = iprot.readString();
13779 
        else:
13780 
          iprot.skip(ftype)
13781 
      else:
13782 
        iprot.skip(ftype)
13783 
      iprot.readFieldEnd()
13784 
    iprot.readStructEnd()
13785 
 
13786 
  def write(self, oprot):
13787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13789 
      return
13790 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 13791 
    if self.couponCode is not None:
3385 varun.gupt 13792 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
13793 
      oprot.writeString(self.couponCode)
13794 
      oprot.writeFieldEnd()
13795 
    oprot.writeFieldStop()
13796 
    oprot.writeStructEnd()
13797 
 
3431 rajveer 13798 
  def validate(self):
13799 
    return
13800 
 
13801 
 
3385 varun.gupt 13802 
  def __repr__(self):
13803 
    L = ['%s=%r' % (key, value)
13804 
      for key, value in self.__dict__.iteritems()]
13805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13806 
 
13807 
  def __eq__(self, other):
13808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13809 
 
13810 
  def __ne__(self, other):
13811 
    return not (self == other)
13812 
 
13813 
class getCartsWithCouponCount_result:
13814 
  """
13815 
  Attributes:
13816 
   - success
13817 
  """
13818 
 
13819 
  thrift_spec = (
13820 
    (0, TType.I64, 'success', None, None, ), # 0
13821 
  )
13822 
 
13823 
  def __init__(self, success=None,):
13824 
    self.success = success
13825 
 
13826 
  def read(self, iprot):
13827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13829 
      return
13830 
    iprot.readStructBegin()
13831 
    while True:
13832 
      (fname, ftype, fid) = iprot.readFieldBegin()
13833 
      if ftype == TType.STOP:
13834 
        break
13835 
      if fid == 0:
13836 
        if ftype == TType.I64:
13837 
          self.success = iprot.readI64();
13838 
        else:
13839 
          iprot.skip(ftype)
13840 
      else:
13841 
        iprot.skip(ftype)
13842 
      iprot.readFieldEnd()
13843 
    iprot.readStructEnd()
13844 
 
13845 
  def write(self, oprot):
13846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13848 
      return
13849 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 13850 
    if self.success is not None:
3385 varun.gupt 13851 
      oprot.writeFieldBegin('success', TType.I64, 0)
13852 
      oprot.writeI64(self.success)
13853 
      oprot.writeFieldEnd()
13854 
    oprot.writeFieldStop()
13855 
    oprot.writeStructEnd()
13856 
 
3431 rajveer 13857 
  def validate(self):
13858 
    return
13859 
 
13860 
 
3385 varun.gupt 13861 
  def __repr__(self):
13862 
    L = ['%s=%r' % (key, value)
13863 
      for key, value in self.__dict__.iteritems()]
13864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13865 
 
13866 
  def __eq__(self, other):
13867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13868 
 
13869 
  def __ne__(self, other):
13870 
    return not (self == other)
3499 mandeep.dh 13871 
 
13872 
class increaseTrustLevel_args:
13873 
  """
13874 
  Attributes:
13875 
   - userId
13876 
   - trustLevelDelta
13877 
  """
13878 
 
13879 
  thrift_spec = (
13880 
    None, # 0
13881 
    (1, TType.I64, 'userId', None, None, ), # 1
13882 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
13883 
  )
13884 
 
13885 
  def __init__(self, userId=None, trustLevelDelta=None,):
13886 
    self.userId = userId
13887 
    self.trustLevelDelta = trustLevelDelta
13888 
 
13889 
  def read(self, iprot):
13890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13892 
      return
13893 
    iprot.readStructBegin()
13894 
    while True:
13895 
      (fname, ftype, fid) = iprot.readFieldBegin()
13896 
      if ftype == TType.STOP:
13897 
        break
13898 
      if fid == 1:
13899 
        if ftype == TType.I64:
13900 
          self.userId = iprot.readI64();
13901 
        else:
13902 
          iprot.skip(ftype)
13903 
      elif fid == 2:
13904 
        if ftype == TType.DOUBLE:
13905 
          self.trustLevelDelta = iprot.readDouble();
13906 
        else:
13907 
          iprot.skip(ftype)
13908 
      else:
13909 
        iprot.skip(ftype)
13910 
      iprot.readFieldEnd()
13911 
    iprot.readStructEnd()
13912 
 
13913 
  def write(self, oprot):
13914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13916 
      return
13917 
    oprot.writeStructBegin('increaseTrustLevel_args')
13918 
    if self.userId is not None:
13919 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13920 
      oprot.writeI64(self.userId)
13921 
      oprot.writeFieldEnd()
13922 
    if self.trustLevelDelta is not None:
13923 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
13924 
      oprot.writeDouble(self.trustLevelDelta)
13925 
      oprot.writeFieldEnd()
13926 
    oprot.writeFieldStop()
13927 
    oprot.writeStructEnd()
13928 
 
13929 
  def validate(self):
13930 
    return
13931 
 
13932 
 
13933 
  def __repr__(self):
13934 
    L = ['%s=%r' % (key, value)
13935 
      for key, value in self.__dict__.iteritems()]
13936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13937 
 
13938 
  def __eq__(self, other):
13939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13940 
 
13941 
  def __ne__(self, other):
13942 
    return not (self == other)
4668 varun.gupt 13943 
 
5407 amar.kumar 13944 
class getTrustLevel_args:
13945 
  """
13946 
  Attributes:
13947 
   - userId
13948 
  """
13949 
 
13950 
  thrift_spec = (
13951 
    None, # 0
13952 
    (1, TType.I64, 'userId', None, None, ), # 1
13953 
  )
13954 
 
13955 
  def __init__(self, userId=None,):
13956 
    self.userId = userId
13957 
 
13958 
  def read(self, iprot):
13959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13961 
      return
13962 
    iprot.readStructBegin()
13963 
    while True:
13964 
      (fname, ftype, fid) = iprot.readFieldBegin()
13965 
      if ftype == TType.STOP:
13966 
        break
13967 
      if fid == 1:
13968 
        if ftype == TType.I64:
13969 
          self.userId = iprot.readI64();
13970 
        else:
13971 
          iprot.skip(ftype)
13972 
      else:
13973 
        iprot.skip(ftype)
13974 
      iprot.readFieldEnd()
13975 
    iprot.readStructEnd()
13976 
 
13977 
  def write(self, oprot):
13978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13980 
      return
13981 
    oprot.writeStructBegin('getTrustLevel_args')
13982 
    if self.userId is not None:
13983 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13984 
      oprot.writeI64(self.userId)
13985 
      oprot.writeFieldEnd()
13986 
    oprot.writeFieldStop()
13987 
    oprot.writeStructEnd()
13988 
 
13989 
  def validate(self):
13990 
    return
13991 
 
13992 
 
13993 
  def __repr__(self):
13994 
    L = ['%s=%r' % (key, value)
13995 
      for key, value in self.__dict__.iteritems()]
13996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13997 
 
13998 
  def __eq__(self, other):
13999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14000 
 
14001 
  def __ne__(self, other):
14002 
    return not (self == other)
14003 
 
14004 
class getTrustLevel_result:
14005 
  """
14006 
  Attributes:
14007 
   - success
14008 
  """
14009 
 
14010 
  thrift_spec = (
14011 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14012 
  )
14013 
 
14014 
  def __init__(self, success=None,):
14015 
    self.success = success
14016 
 
14017 
  def read(self, iprot):
14018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14020 
      return
14021 
    iprot.readStructBegin()
14022 
    while True:
14023 
      (fname, ftype, fid) = iprot.readFieldBegin()
14024 
      if ftype == TType.STOP:
14025 
        break
14026 
      if fid == 0:
14027 
        if ftype == TType.DOUBLE:
14028 
          self.success = iprot.readDouble();
14029 
        else:
14030 
          iprot.skip(ftype)
14031 
      else:
14032 
        iprot.skip(ftype)
14033 
      iprot.readFieldEnd()
14034 
    iprot.readStructEnd()
14035 
 
14036 
  def write(self, oprot):
14037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14039 
      return
14040 
    oprot.writeStructBegin('getTrustLevel_result')
14041 
    if self.success is not None:
14042 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14043 
      oprot.writeDouble(self.success)
14044 
      oprot.writeFieldEnd()
14045 
    oprot.writeFieldStop()
14046 
    oprot.writeStructEnd()
14047 
 
14048 
  def validate(self):
14049 
    return
14050 
 
14051 
 
14052 
  def __repr__(self):
14053 
    L = ['%s=%r' % (key, value)
14054 
      for key, value in self.__dict__.iteritems()]
14055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14056 
 
14057 
  def __eq__(self, other):
14058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14059 
 
14060 
  def __ne__(self, other):
14061 
    return not (self == other)
14062 
 
4668 varun.gupt 14063 
class showCODOption_args:
14064 
  """
14065 
  Attributes:
14066 
   - cartId
14067 
   - sourceId
14068 
   - pincode
14069 
  """
14070 
 
14071 
  thrift_spec = (
14072 
    None, # 0
14073 
    (1, TType.I64, 'cartId', None, None, ), # 1
14074 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14075 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14076 
  )
14077 
 
14078 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14079 
    self.cartId = cartId
14080 
    self.sourceId = sourceId
14081 
    self.pincode = pincode
14082 
 
14083 
  def read(self, iprot):
14084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14086 
      return
14087 
    iprot.readStructBegin()
14088 
    while True:
14089 
      (fname, ftype, fid) = iprot.readFieldBegin()
14090 
      if ftype == TType.STOP:
14091 
        break
14092 
      if fid == 1:
14093 
        if ftype == TType.I64:
14094 
          self.cartId = iprot.readI64();
14095 
        else:
14096 
          iprot.skip(ftype)
14097 
      elif fid == 2:
14098 
        if ftype == TType.I64:
14099 
          self.sourceId = iprot.readI64();
14100 
        else:
14101 
          iprot.skip(ftype)
14102 
      elif fid == 3:
14103 
        if ftype == TType.STRING:
14104 
          self.pincode = iprot.readString();
14105 
        else:
14106 
          iprot.skip(ftype)
14107 
      else:
14108 
        iprot.skip(ftype)
14109 
      iprot.readFieldEnd()
14110 
    iprot.readStructEnd()
14111 
 
14112 
  def write(self, oprot):
14113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14115 
      return
14116 
    oprot.writeStructBegin('showCODOption_args')
14117 
    if self.cartId is not None:
14118 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14119 
      oprot.writeI64(self.cartId)
14120 
      oprot.writeFieldEnd()
14121 
    if self.sourceId is not None:
14122 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14123 
      oprot.writeI64(self.sourceId)
14124 
      oprot.writeFieldEnd()
14125 
    if self.pincode is not None:
14126 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14127 
      oprot.writeString(self.pincode)
14128 
      oprot.writeFieldEnd()
14129 
    oprot.writeFieldStop()
14130 
    oprot.writeStructEnd()
14131 
 
14132 
  def validate(self):
14133 
    return
14134 
 
14135 
 
14136 
  def __repr__(self):
14137 
    L = ['%s=%r' % (key, value)
14138 
      for key, value in self.__dict__.iteritems()]
14139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14140 
 
14141 
  def __eq__(self, other):
14142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14143 
 
14144 
  def __ne__(self, other):
14145 
    return not (self == other)
14146 
 
14147 
class showCODOption_result:
14148 
  """
14149 
  Attributes:
14150 
   - success
14151 
  """
14152 
 
14153 
  thrift_spec = (
14154 
    (0, TType.BOOL, 'success', None, None, ), # 0
14155 
  )
14156 
 
14157 
  def __init__(self, success=None,):
14158 
    self.success = success
14159 
 
14160 
  def read(self, iprot):
14161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14163 
      return
14164 
    iprot.readStructBegin()
14165 
    while True:
14166 
      (fname, ftype, fid) = iprot.readFieldBegin()
14167 
      if ftype == TType.STOP:
14168 
        break
14169 
      if fid == 0:
14170 
        if ftype == TType.BOOL:
14171 
          self.success = iprot.readBool();
14172 
        else:
14173 
          iprot.skip(ftype)
14174 
      else:
14175 
        iprot.skip(ftype)
14176 
      iprot.readFieldEnd()
14177 
    iprot.readStructEnd()
14178 
 
14179 
  def write(self, oprot):
14180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14182 
      return
14183 
    oprot.writeStructBegin('showCODOption_result')
14184 
    if self.success is not None:
14185 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14186 
      oprot.writeBool(self.success)
14187 
      oprot.writeFieldEnd()
14188 
    oprot.writeFieldStop()
14189 
    oprot.writeStructEnd()
14190 
 
14191 
  def validate(self):
14192 
    return
14193 
 
14194 
 
14195 
  def __repr__(self):
14196 
    L = ['%s=%r' % (key, value)
14197 
      for key, value in self.__dict__.iteritems()]
14198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14199 
 
14200 
  def __eq__(self, other):
14201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14202 
 
14203 
  def __ne__(self, other):
14204 
    return not (self == other)
5623 anupam.sin 14205 
 
14206 
class getUserEmails_args:
14207 
  """
14208 
  Attributes:
14209 
   - startDate
14210 
   - endDate
14211 
  """
14212 
 
14213 
  thrift_spec = (
14214 
    None, # 0
14215 
    (1, TType.I64, 'startDate', None, None, ), # 1
14216 
    (2, TType.I64, 'endDate', None, None, ), # 2
14217 
  )
14218 
 
14219 
  def __init__(self, startDate=None, endDate=None,):
14220 
    self.startDate = startDate
14221 
    self.endDate = endDate
14222 
 
14223 
  def read(self, iprot):
14224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14226 
      return
14227 
    iprot.readStructBegin()
14228 
    while True:
14229 
      (fname, ftype, fid) = iprot.readFieldBegin()
14230 
      if ftype == TType.STOP:
14231 
        break
14232 
      if fid == 1:
14233 
        if ftype == TType.I64:
14234 
          self.startDate = iprot.readI64();
14235 
        else:
14236 
          iprot.skip(ftype)
14237 
      elif fid == 2:
14238 
        if ftype == TType.I64:
14239 
          self.endDate = iprot.readI64();
14240 
        else:
14241 
          iprot.skip(ftype)
14242 
      else:
14243 
        iprot.skip(ftype)
14244 
      iprot.readFieldEnd()
14245 
    iprot.readStructEnd()
14246 
 
14247 
  def write(self, oprot):
14248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14250 
      return
14251 
    oprot.writeStructBegin('getUserEmails_args')
14252 
    if self.startDate is not None:
14253 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14254 
      oprot.writeI64(self.startDate)
14255 
      oprot.writeFieldEnd()
14256 
    if self.endDate is not None:
14257 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14258 
      oprot.writeI64(self.endDate)
14259 
      oprot.writeFieldEnd()
14260 
    oprot.writeFieldStop()
14261 
    oprot.writeStructEnd()
14262 
 
14263 
  def validate(self):
14264 
    return
14265 
 
14266 
 
14267 
  def __repr__(self):
14268 
    L = ['%s=%r' % (key, value)
14269 
      for key, value in self.__dict__.iteritems()]
14270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14271 
 
14272 
  def __eq__(self, other):
14273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14274 
 
14275 
  def __ne__(self, other):
14276 
    return not (self == other)
14277 
 
14278 
class getUserEmails_result:
14279 
  """
14280 
  Attributes:
14281 
   - success
14282 
  """
14283 
 
14284 
  thrift_spec = (
14285 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14286 
  )
14287 
 
14288 
  def __init__(self, success=None,):
14289 
    self.success = success
14290 
 
14291 
  def read(self, iprot):
14292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14294 
      return
14295 
    iprot.readStructBegin()
14296 
    while True:
14297 
      (fname, ftype, fid) = iprot.readFieldBegin()
14298 
      if ftype == TType.STOP:
14299 
        break
14300 
      if fid == 0:
14301 
        if ftype == TType.LIST:
14302 
          self.success = []
11980 amit.gupta 14303 
          (_etype214, _size211) = iprot.readListBegin()
14304 
          for _i215 in xrange(_size211):
14305 
            _elem216 = iprot.readString();
14306 
            self.success.append(_elem216)
5623 anupam.sin 14307 
          iprot.readListEnd()
14308 
        else:
14309 
          iprot.skip(ftype)
14310 
      else:
14311 
        iprot.skip(ftype)
14312 
      iprot.readFieldEnd()
14313 
    iprot.readStructEnd()
14314 
 
14315 
  def write(self, oprot):
14316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14318 
      return
14319 
    oprot.writeStructBegin('getUserEmails_result')
14320 
    if self.success is not None:
14321 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14322 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14323 
      for iter217 in self.success:
14324 
        oprot.writeString(iter217)
5623 anupam.sin 14325 
      oprot.writeListEnd()
14326 
      oprot.writeFieldEnd()
14327 
    oprot.writeFieldStop()
14328 
    oprot.writeStructEnd()
14329 
 
14330 
  def validate(self):
14331 
    return
14332 
 
14333 
 
14334 
  def __repr__(self):
14335 
    L = ['%s=%r' % (key, value)
14336 
      for key, value in self.__dict__.iteritems()]
14337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14338 
 
14339 
  def __eq__(self, other):
14340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14341 
 
14342 
  def __ne__(self, other):
14343 
    return not (self == other)
6821 amar.kumar 14344 
 
6903 anupam.sin 14345 
class insureItem_args:
14346 
  """
14347 
  Attributes:
14348 
   - itemId
14349 
   - cartId
14350 
   - toInsure
9299 kshitij.so 14351 
   - insurerType
6903 anupam.sin 14352 
  """
14353 
 
14354 
  thrift_spec = (
14355 
    None, # 0
14356 
    (1, TType.I64, 'itemId', None, None, ), # 1
14357 
    (2, TType.I64, 'cartId', None, None, ), # 2
14358 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14359 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14360 
  )
14361 
 
9299 kshitij.so 14362 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14363 
    self.itemId = itemId
14364 
    self.cartId = cartId
14365 
    self.toInsure = toInsure
9299 kshitij.so 14366 
    self.insurerType = insurerType
6903 anupam.sin 14367 
 
14368 
  def read(self, iprot):
14369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14371 
      return
14372 
    iprot.readStructBegin()
14373 
    while True:
14374 
      (fname, ftype, fid) = iprot.readFieldBegin()
14375 
      if ftype == TType.STOP:
14376 
        break
14377 
      if fid == 1:
14378 
        if ftype == TType.I64:
14379 
          self.itemId = iprot.readI64();
14380 
        else:
14381 
          iprot.skip(ftype)
14382 
      elif fid == 2:
14383 
        if ftype == TType.I64:
14384 
          self.cartId = iprot.readI64();
14385 
        else:
14386 
          iprot.skip(ftype)
14387 
      elif fid == 3:
14388 
        if ftype == TType.BOOL:
14389 
          self.toInsure = iprot.readBool();
14390 
        else:
14391 
          iprot.skip(ftype)
9299 kshitij.so 14392 
      elif fid == 4:
14393 
        if ftype == TType.I32:
14394 
          self.insurerType = iprot.readI32();
14395 
        else:
14396 
          iprot.skip(ftype)
6903 anupam.sin 14397 
      else:
14398 
        iprot.skip(ftype)
14399 
      iprot.readFieldEnd()
14400 
    iprot.readStructEnd()
14401 
 
14402 
  def write(self, oprot):
14403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14405 
      return
14406 
    oprot.writeStructBegin('insureItem_args')
14407 
    if self.itemId is not None:
14408 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14409 
      oprot.writeI64(self.itemId)
14410 
      oprot.writeFieldEnd()
14411 
    if self.cartId is not None:
14412 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14413 
      oprot.writeI64(self.cartId)
14414 
      oprot.writeFieldEnd()
14415 
    if self.toInsure is not None:
14416 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14417 
      oprot.writeBool(self.toInsure)
14418 
      oprot.writeFieldEnd()
9299 kshitij.so 14419 
    if self.insurerType is not None:
14420 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14421 
      oprot.writeI32(self.insurerType)
14422 
      oprot.writeFieldEnd()
6903 anupam.sin 14423 
    oprot.writeFieldStop()
14424 
    oprot.writeStructEnd()
14425 
 
14426 
  def validate(self):
14427 
    return
14428 
 
14429 
 
14430 
  def __repr__(self):
14431 
    L = ['%s=%r' % (key, value)
14432 
      for key, value in self.__dict__.iteritems()]
14433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14434 
 
14435 
  def __eq__(self, other):
14436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14437 
 
14438 
  def __ne__(self, other):
14439 
    return not (self == other)
14440 
 
14441 
class insureItem_result:
14442 
  """
14443 
  Attributes:
14444 
   - success
14445 
  """
14446 
 
14447 
  thrift_spec = (
14448 
    (0, TType.BOOL, 'success', None, None, ), # 0
14449 
  )
14450 
 
14451 
  def __init__(self, success=None,):
14452 
    self.success = success
14453 
 
14454 
  def read(self, iprot):
14455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14457 
      return
14458 
    iprot.readStructBegin()
14459 
    while True:
14460 
      (fname, ftype, fid) = iprot.readFieldBegin()
14461 
      if ftype == TType.STOP:
14462 
        break
14463 
      if fid == 0:
14464 
        if ftype == TType.BOOL:
14465 
          self.success = iprot.readBool();
14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      else:
14469 
        iprot.skip(ftype)
14470 
      iprot.readFieldEnd()
14471 
    iprot.readStructEnd()
14472 
 
14473 
  def write(self, oprot):
14474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14476 
      return
14477 
    oprot.writeStructBegin('insureItem_result')
14478 
    if self.success is not None:
14479 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14480 
      oprot.writeBool(self.success)
14481 
      oprot.writeFieldEnd()
14482 
    oprot.writeFieldStop()
14483 
    oprot.writeStructEnd()
14484 
 
14485 
  def validate(self):
14486 
    return
14487 
 
14488 
 
14489 
  def __repr__(self):
14490 
    L = ['%s=%r' % (key, value)
14491 
      for key, value in self.__dict__.iteritems()]
14492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14493 
 
14494 
  def __eq__(self, other):
14495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14496 
 
14497 
  def __ne__(self, other):
14498 
    return not (self == other)
14499 
 
14500 
class cancelInsurance_args:
14501 
  """
14502 
  Attributes:
14503 
   - cartId
14504 
  """
14505 
 
14506 
  thrift_spec = (
14507 
    None, # 0
14508 
    (1, TType.I64, 'cartId', None, None, ), # 1
14509 
  )
14510 
 
14511 
  def __init__(self, cartId=None,):
14512 
    self.cartId = cartId
14513 
 
14514 
  def read(self, iprot):
14515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14517 
      return
14518 
    iprot.readStructBegin()
14519 
    while True:
14520 
      (fname, ftype, fid) = iprot.readFieldBegin()
14521 
      if ftype == TType.STOP:
14522 
        break
14523 
      if fid == 1:
14524 
        if ftype == TType.I64:
14525 
          self.cartId = iprot.readI64();
14526 
        else:
14527 
          iprot.skip(ftype)
14528 
      else:
14529 
        iprot.skip(ftype)
14530 
      iprot.readFieldEnd()
14531 
    iprot.readStructEnd()
14532 
 
14533 
  def write(self, oprot):
14534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14536 
      return
14537 
    oprot.writeStructBegin('cancelInsurance_args')
14538 
    if self.cartId is not None:
14539 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14540 
      oprot.writeI64(self.cartId)
14541 
      oprot.writeFieldEnd()
14542 
    oprot.writeFieldStop()
14543 
    oprot.writeStructEnd()
14544 
 
14545 
  def validate(self):
14546 
    return
14547 
 
14548 
 
14549 
  def __repr__(self):
14550 
    L = ['%s=%r' % (key, value)
14551 
      for key, value in self.__dict__.iteritems()]
14552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14553 
 
14554 
  def __eq__(self, other):
14555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14556 
 
14557 
  def __ne__(self, other):
14558 
    return not (self == other)
14559 
 
14560 
class cancelInsurance_result:
14561 
  """
14562 
  Attributes:
14563 
   - success
14564 
  """
14565 
 
14566 
  thrift_spec = (
14567 
    (0, TType.BOOL, 'success', None, None, ), # 0
14568 
  )
14569 
 
14570 
  def __init__(self, success=None,):
14571 
    self.success = success
14572 
 
14573 
  def read(self, iprot):
14574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14576 
      return
14577 
    iprot.readStructBegin()
14578 
    while True:
14579 
      (fname, ftype, fid) = iprot.readFieldBegin()
14580 
      if ftype == TType.STOP:
14581 
        break
14582 
      if fid == 0:
14583 
        if ftype == TType.BOOL:
14584 
          self.success = iprot.readBool();
14585 
        else:
14586 
          iprot.skip(ftype)
14587 
      else:
14588 
        iprot.skip(ftype)
14589 
      iprot.readFieldEnd()
14590 
    iprot.readStructEnd()
14591 
 
14592 
  def write(self, oprot):
14593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14595 
      return
14596 
    oprot.writeStructBegin('cancelInsurance_result')
14597 
    if self.success is not None:
14598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14599 
      oprot.writeBool(self.success)
14600 
      oprot.writeFieldEnd()
14601 
    oprot.writeFieldStop()
14602 
    oprot.writeStructEnd()
14603 
 
14604 
  def validate(self):
14605 
    return
14606 
 
14607 
 
14608 
  def __repr__(self):
14609 
    L = ['%s=%r' % (key, value)
14610 
      for key, value in self.__dict__.iteritems()]
14611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14612 
 
14613 
  def __eq__(self, other):
14614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14615 
 
14616 
  def __ne__(self, other):
14617 
    return not (self == other)
14618 
 
14619 
class storeInsuranceSpecificDetails_args:
14620 
  """
14621 
  Attributes:
14622 
   - addressId
14623 
   - dob
14624 
   - guardianName
14625 
  """
14626 
 
14627 
  thrift_spec = (
14628 
    None, # 0
14629 
    (1, TType.I64, 'addressId', None, None, ), # 1
14630 
    (2, TType.STRING, 'dob', None, None, ), # 2
14631 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14632 
  )
14633 
 
14634 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14635 
    self.addressId = addressId
14636 
    self.dob = dob
14637 
    self.guardianName = guardianName
14638 
 
14639 
  def read(self, iprot):
14640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14642 
      return
14643 
    iprot.readStructBegin()
14644 
    while True:
14645 
      (fname, ftype, fid) = iprot.readFieldBegin()
14646 
      if ftype == TType.STOP:
14647 
        break
14648 
      if fid == 1:
14649 
        if ftype == TType.I64:
14650 
          self.addressId = iprot.readI64();
14651 
        else:
14652 
          iprot.skip(ftype)
14653 
      elif fid == 2:
14654 
        if ftype == TType.STRING:
14655 
          self.dob = iprot.readString();
14656 
        else:
14657 
          iprot.skip(ftype)
14658 
      elif fid == 3:
14659 
        if ftype == TType.STRING:
14660 
          self.guardianName = iprot.readString();
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      else:
14664 
        iprot.skip(ftype)
14665 
      iprot.readFieldEnd()
14666 
    iprot.readStructEnd()
14667 
 
14668 
  def write(self, oprot):
14669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14671 
      return
14672 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14673 
    if self.addressId is not None:
14674 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14675 
      oprot.writeI64(self.addressId)
14676 
      oprot.writeFieldEnd()
14677 
    if self.dob is not None:
14678 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14679 
      oprot.writeString(self.dob)
14680 
      oprot.writeFieldEnd()
14681 
    if self.guardianName is not None:
14682 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14683 
      oprot.writeString(self.guardianName)
14684 
      oprot.writeFieldEnd()
14685 
    oprot.writeFieldStop()
14686 
    oprot.writeStructEnd()
14687 
 
14688 
  def validate(self):
14689 
    return
14690 
 
14691 
 
14692 
  def __repr__(self):
14693 
    L = ['%s=%r' % (key, value)
14694 
      for key, value in self.__dict__.iteritems()]
14695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14696 
 
14697 
  def __eq__(self, other):
14698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14699 
 
14700 
  def __ne__(self, other):
14701 
    return not (self == other)
14702 
 
14703 
class storeInsuranceSpecificDetails_result:
14704 
  """
14705 
  Attributes:
14706 
   - success
14707 
  """
14708 
 
14709 
  thrift_spec = (
14710 
    (0, TType.BOOL, 'success', None, None, ), # 0
14711 
  )
14712 
 
14713 
  def __init__(self, success=None,):
14714 
    self.success = success
14715 
 
14716 
  def read(self, iprot):
14717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14719 
      return
14720 
    iprot.readStructBegin()
14721 
    while True:
14722 
      (fname, ftype, fid) = iprot.readFieldBegin()
14723 
      if ftype == TType.STOP:
14724 
        break
14725 
      if fid == 0:
14726 
        if ftype == TType.BOOL:
14727 
          self.success = iprot.readBool();
14728 
        else:
14729 
          iprot.skip(ftype)
14730 
      else:
14731 
        iprot.skip(ftype)
14732 
      iprot.readFieldEnd()
14733 
    iprot.readStructEnd()
14734 
 
14735 
  def write(self, oprot):
14736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14738 
      return
14739 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
14740 
    if self.success is not None:
14741 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14742 
      oprot.writeBool(self.success)
14743 
      oprot.writeFieldEnd()
14744 
    oprot.writeFieldStop()
14745 
    oprot.writeStructEnd()
14746 
 
14747 
  def validate(self):
14748 
    return
14749 
 
14750 
 
14751 
  def __repr__(self):
14752 
    L = ['%s=%r' % (key, value)
14753 
      for key, value in self.__dict__.iteritems()]
14754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14755 
 
14756 
  def __eq__(self, other):
14757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14758 
 
14759 
  def __ne__(self, other):
14760 
    return not (self == other)
14761 
 
14762 
class isInsuranceDetailPresent_args:
14763 
  """
14764 
  Attributes:
14765 
   - addressId
14766 
  """
14767 
 
14768 
  thrift_spec = (
14769 
    None, # 0
14770 
    (1, TType.I64, 'addressId', None, None, ), # 1
14771 
  )
14772 
 
14773 
  def __init__(self, addressId=None,):
14774 
    self.addressId = addressId
14775 
 
14776 
  def read(self, iprot):
14777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14779 
      return
14780 
    iprot.readStructBegin()
14781 
    while True:
14782 
      (fname, ftype, fid) = iprot.readFieldBegin()
14783 
      if ftype == TType.STOP:
14784 
        break
14785 
      if fid == 1:
14786 
        if ftype == TType.I64:
14787 
          self.addressId = iprot.readI64();
14788 
        else:
14789 
          iprot.skip(ftype)
14790 
      else:
14791 
        iprot.skip(ftype)
14792 
      iprot.readFieldEnd()
14793 
    iprot.readStructEnd()
14794 
 
14795 
  def write(self, oprot):
14796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14798 
      return
14799 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
14800 
    if self.addressId is not None:
14801 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14802 
      oprot.writeI64(self.addressId)
14803 
      oprot.writeFieldEnd()
14804 
    oprot.writeFieldStop()
14805 
    oprot.writeStructEnd()
14806 
 
14807 
  def validate(self):
14808 
    return
14809 
 
14810 
 
14811 
  def __repr__(self):
14812 
    L = ['%s=%r' % (key, value)
14813 
      for key, value in self.__dict__.iteritems()]
14814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14815 
 
14816 
  def __eq__(self, other):
14817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14818 
 
14819 
  def __ne__(self, other):
14820 
    return not (self == other)
14821 
 
14822 
class isInsuranceDetailPresent_result:
14823 
  """
14824 
  Attributes:
14825 
   - success
14826 
  """
14827 
 
14828 
  thrift_spec = (
14829 
    (0, TType.BOOL, 'success', None, None, ), # 0
14830 
  )
14831 
 
14832 
  def __init__(self, success=None,):
14833 
    self.success = success
14834 
 
14835 
  def read(self, iprot):
14836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14838 
      return
14839 
    iprot.readStructBegin()
14840 
    while True:
14841 
      (fname, ftype, fid) = iprot.readFieldBegin()
14842 
      if ftype == TType.STOP:
14843 
        break
14844 
      if fid == 0:
14845 
        if ftype == TType.BOOL:
14846 
          self.success = iprot.readBool();
14847 
        else:
14848 
          iprot.skip(ftype)
14849 
      else:
14850 
        iprot.skip(ftype)
14851 
      iprot.readFieldEnd()
14852 
    iprot.readStructEnd()
14853 
 
14854 
  def write(self, oprot):
14855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14857 
      return
14858 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
14859 
    if self.success is not None:
14860 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14861 
      oprot.writeBool(self.success)
14862 
      oprot.writeFieldEnd()
14863 
    oprot.writeFieldStop()
14864 
    oprot.writeStructEnd()
14865 
 
14866 
  def validate(self):
14867 
    return
14868 
 
14869 
 
14870 
  def __repr__(self):
14871 
    L = ['%s=%r' % (key, value)
14872 
      for key, value in self.__dict__.iteritems()]
14873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14874 
 
14875 
  def __eq__(self, other):
14876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14877 
 
14878 
  def __ne__(self, other):
14879 
    return not (self == other)
14880 
 
9791 rajveer 14881 
class getProductsAddedToCart_args:
6821 amar.kumar 14882 
  """
14883 
  Attributes:
14884 
   - startDate
14885 
   - endDate
14886 
  """
14887 
 
14888 
  thrift_spec = (
14889 
    None, # 0
9791 rajveer 14890 
    (1, TType.I64, 'startDate', None, None, ), # 1
14891 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 14892 
  )
14893 
 
9791 rajveer 14894 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 14895 
    self.startDate = startDate
14896 
    self.endDate = endDate
14897 
 
14898 
  def read(self, iprot):
14899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14901 
      return
14902 
    iprot.readStructBegin()
14903 
    while True:
14904 
      (fname, ftype, fid) = iprot.readFieldBegin()
14905 
      if ftype == TType.STOP:
14906 
        break
14907 
      if fid == 1:
14908 
        if ftype == TType.I64:
9791 rajveer 14909 
          self.startDate = iprot.readI64();
6821 amar.kumar 14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      elif fid == 2:
14913 
        if ftype == TType.I64:
14914 
          self.endDate = iprot.readI64();
14915 
        else:
14916 
          iprot.skip(ftype)
14917 
      else:
14918 
        iprot.skip(ftype)
14919 
      iprot.readFieldEnd()
14920 
    iprot.readStructEnd()
14921 
 
14922 
  def write(self, oprot):
14923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14925 
      return
9791 rajveer 14926 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 14927 
    if self.startDate is not None:
9791 rajveer 14928 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 14929 
      oprot.writeI64(self.startDate)
14930 
      oprot.writeFieldEnd()
14931 
    if self.endDate is not None:
9791 rajveer 14932 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 14933 
      oprot.writeI64(self.endDate)
14934 
      oprot.writeFieldEnd()
14935 
    oprot.writeFieldStop()
14936 
    oprot.writeStructEnd()
14937 
 
14938 
  def validate(self):
14939 
    return
14940 
 
14941 
 
14942 
  def __repr__(self):
14943 
    L = ['%s=%r' % (key, value)
14944 
      for key, value in self.__dict__.iteritems()]
14945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14946 
 
14947 
  def __eq__(self, other):
14948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14949 
 
14950 
  def __ne__(self, other):
14951 
    return not (self == other)
14952 
 
9791 rajveer 14953 
class getProductsAddedToCart_result:
6821 amar.kumar 14954 
  """
14955 
  Attributes:
14956 
   - success
14957 
  """
14958 
 
14959 
  thrift_spec = (
9791 rajveer 14960 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 14961 
  )
14962 
 
14963 
  def __init__(self, success=None,):
14964 
    self.success = success
14965 
 
14966 
  def read(self, iprot):
14967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14969 
      return
14970 
    iprot.readStructBegin()
14971 
    while True:
14972 
      (fname, ftype, fid) = iprot.readFieldBegin()
14973 
      if ftype == TType.STOP:
14974 
        break
14975 
      if fid == 0:
9791 rajveer 14976 
        if ftype == TType.LIST:
14977 
          self.success = []
11980 amit.gupta 14978 
          (_etype221, _size218) = iprot.readListBegin()
14979 
          for _i222 in xrange(_size218):
14980 
            _elem223 = iprot.readI64();
14981 
            self.success.append(_elem223)
9791 rajveer 14982 
          iprot.readListEnd()
6821 amar.kumar 14983 
        else:
14984 
          iprot.skip(ftype)
14985 
      else:
14986 
        iprot.skip(ftype)
14987 
      iprot.readFieldEnd()
14988 
    iprot.readStructEnd()
14989 
 
14990 
  def write(self, oprot):
14991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14993 
      return
9791 rajveer 14994 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 14995 
    if self.success is not None:
9791 rajveer 14996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14997 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 14998 
      for iter224 in self.success:
14999 
        oprot.writeI64(iter224)
9791 rajveer 15000 
      oprot.writeListEnd()
6821 amar.kumar 15001 
      oprot.writeFieldEnd()
15002 
    oprot.writeFieldStop()
15003 
    oprot.writeStructEnd()
15004 
 
15005 
  def validate(self):
15006 
    return
15007 
 
15008 
 
15009 
  def __repr__(self):
15010 
    L = ['%s=%r' % (key, value)
15011 
      for key, value in self.__dict__.iteritems()]
15012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15013 
 
15014 
  def __eq__(self, other):
15015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15016 
 
15017 
  def __ne__(self, other):
15018 
    return not (self == other)
11592 amit.gupta 15019 
 
15020 
class validateCartPlus_args:
15021 
  """
15022 
  Attributes:
15023 
   - cartId
15024 
   - sourceId
11980 amit.gupta 15025 
   - dealerCoupon
11592 amit.gupta 15026 
  """
15027 
 
15028 
  thrift_spec = (
15029 
    None, # 0
15030 
    (1, TType.I64, 'cartId', None, None, ), # 1
15031 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15032 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15033 
  )
15034 
 
11980 amit.gupta 15035 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15036 
    self.cartId = cartId
15037 
    self.sourceId = sourceId
11980 amit.gupta 15038 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15039 
 
15040 
  def read(self, iprot):
15041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15043 
      return
15044 
    iprot.readStructBegin()
15045 
    while True:
15046 
      (fname, ftype, fid) = iprot.readFieldBegin()
15047 
      if ftype == TType.STOP:
15048 
        break
15049 
      if fid == 1:
15050 
        if ftype == TType.I64:
15051 
          self.cartId = iprot.readI64();
15052 
        else:
15053 
          iprot.skip(ftype)
15054 
      elif fid == 2:
15055 
        if ftype == TType.I64:
15056 
          self.sourceId = iprot.readI64();
15057 
        else:
15058 
          iprot.skip(ftype)
11980 amit.gupta 15059 
      elif fid == 3:
15060 
        if ftype == TType.STRING:
15061 
          self.dealerCoupon = iprot.readString();
15062 
        else:
15063 
          iprot.skip(ftype)
11592 amit.gupta 15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
15073 
    oprot.writeStructBegin('validateCartPlus_args')
15074 
    if self.cartId is not None:
15075 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15076 
      oprot.writeI64(self.cartId)
15077 
      oprot.writeFieldEnd()
15078 
    if self.sourceId is not None:
15079 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15080 
      oprot.writeI64(self.sourceId)
15081 
      oprot.writeFieldEnd()
11980 amit.gupta 15082 
    if self.dealerCoupon is not None:
15083 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15084 
      oprot.writeString(self.dealerCoupon)
15085 
      oprot.writeFieldEnd()
11592 amit.gupta 15086 
    oprot.writeFieldStop()
15087 
    oprot.writeStructEnd()
15088 
 
15089 
  def validate(self):
15090 
    return
15091 
 
15092 
 
15093 
  def __repr__(self):
15094 
    L = ['%s=%r' % (key, value)
15095 
      for key, value in self.__dict__.iteritems()]
15096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15097 
 
15098 
  def __eq__(self, other):
15099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15100 
 
15101 
  def __ne__(self, other):
15102 
    return not (self == other)
15103 
 
15104 
class validateCartPlus_result:
15105 
  """
15106 
  Attributes:
15107 
   - success
15108 
   - scex
15109 
  """
15110 
 
15111 
  thrift_spec = (
15112 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15113 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15114 
  )
15115 
 
15116 
  def __init__(self, success=None, scex=None,):
15117 
    self.success = success
15118 
    self.scex = scex
15119 
 
15120 
  def read(self, iprot):
15121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15123 
      return
15124 
    iprot.readStructBegin()
15125 
    while True:
15126 
      (fname, ftype, fid) = iprot.readFieldBegin()
15127 
      if ftype == TType.STOP:
15128 
        break
15129 
      if fid == 0:
15130 
        if ftype == TType.STRUCT:
15131 
          self.success = CartPlus()
15132 
          self.success.read(iprot)
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      elif fid == 1:
15136 
        if ftype == TType.STRUCT:
15137 
          self.scex = ShoppingCartException()
15138 
          self.scex.read(iprot)
15139 
        else:
15140 
          iprot.skip(ftype)
15141 
      else:
15142 
        iprot.skip(ftype)
15143 
      iprot.readFieldEnd()
15144 
    iprot.readStructEnd()
15145 
 
15146 
  def write(self, oprot):
15147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15149 
      return
15150 
    oprot.writeStructBegin('validateCartPlus_result')
15151 
    if self.success is not None:
15152 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15153 
      self.success.write(oprot)
15154 
      oprot.writeFieldEnd()
15155 
    if self.scex is not None:
15156 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15157 
      self.scex.write(oprot)
15158 
      oprot.writeFieldEnd()
15159 
    oprot.writeFieldStop()
15160 
    oprot.writeStructEnd()
15161 
 
15162 
  def validate(self):
15163 
    return
15164 
 
15165 
 
15166 
  def __repr__(self):
15167 
    L = ['%s=%r' % (key, value)
15168 
      for key, value in self.__dict__.iteritems()]
15169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15170 
 
15171 
  def __eq__(self, other):
15172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15173 
 
15174 
  def __ne__(self, other):
15175 
    return not (self == other)
11679 vikram.rag 15176 
 
15177 
class isPrivateDealUser_args:
15178 
  """
15179 
  Attributes:
15180 
   - userId
15181 
  """
15182 
 
15183 
  thrift_spec = (
15184 
    None, # 0
15185 
    (1, TType.I64, 'userId', None, None, ), # 1
15186 
  )
15187 
 
15188 
  def __init__(self, userId=None,):
15189 
    self.userId = userId
15190 
 
15191 
  def read(self, iprot):
15192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15194 
      return
15195 
    iprot.readStructBegin()
15196 
    while True:
15197 
      (fname, ftype, fid) = iprot.readFieldBegin()
15198 
      if ftype == TType.STOP:
15199 
        break
15200 
      if fid == 1:
15201 
        if ftype == TType.I64:
15202 
          self.userId = iprot.readI64();
15203 
        else:
15204 
          iprot.skip(ftype)
15205 
      else:
15206 
        iprot.skip(ftype)
15207 
      iprot.readFieldEnd()
15208 
    iprot.readStructEnd()
15209 
 
15210 
  def write(self, oprot):
15211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15213 
      return
15214 
    oprot.writeStructBegin('isPrivateDealUser_args')
15215 
    if self.userId is not None:
15216 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15217 
      oprot.writeI64(self.userId)
15218 
      oprot.writeFieldEnd()
15219 
    oprot.writeFieldStop()
15220 
    oprot.writeStructEnd()
15221 
 
15222 
  def validate(self):
15223 
    return
15224 
 
15225 
 
15226 
  def __repr__(self):
15227 
    L = ['%s=%r' % (key, value)
15228 
      for key, value in self.__dict__.iteritems()]
15229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15230 
 
15231 
  def __eq__(self, other):
15232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15233 
 
15234 
  def __ne__(self, other):
15235 
    return not (self == other)
15236 
 
15237 
class isPrivateDealUser_result:
15238 
  """
15239 
  Attributes:
15240 
   - success
15241 
  """
15242 
 
15243 
  thrift_spec = (
15244 
    (0, TType.BOOL, 'success', None, None, ), # 0
15245 
  )
15246 
 
15247 
  def __init__(self, success=None,):
15248 
    self.success = success
15249 
 
15250 
  def read(self, iprot):
15251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15253 
      return
15254 
    iprot.readStructBegin()
15255 
    while True:
15256 
      (fname, ftype, fid) = iprot.readFieldBegin()
15257 
      if ftype == TType.STOP:
15258 
        break
15259 
      if fid == 0:
15260 
        if ftype == TType.BOOL:
15261 
          self.success = iprot.readBool();
15262 
        else:
15263 
          iprot.skip(ftype)
15264 
      else:
15265 
        iprot.skip(ftype)
15266 
      iprot.readFieldEnd()
15267 
    iprot.readStructEnd()
15268 
 
15269 
  def write(self, oprot):
15270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15272 
      return
15273 
    oprot.writeStructBegin('isPrivateDealUser_result')
15274 
    if self.success is not None:
15275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15276 
      oprot.writeBool(self.success)
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)
11890 kshitij.so 15295 
 
15296 
class addPrivateDealUser_args:
15297 
  """
15298 
  Attributes:
15299 
   - userId
15300 
  """
15301 
 
15302 
  thrift_spec = (
15303 
    None, # 0
15304 
    (1, TType.I64, 'userId', None, None, ), # 1
15305 
  )
15306 
 
15307 
  def __init__(self, userId=None,):
15308 
    self.userId = userId
15309 
 
15310 
  def read(self, iprot):
15311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15313 
      return
15314 
    iprot.readStructBegin()
15315 
    while True:
15316 
      (fname, ftype, fid) = iprot.readFieldBegin()
15317 
      if ftype == TType.STOP:
15318 
        break
15319 
      if fid == 1:
15320 
        if ftype == TType.I64:
15321 
          self.userId = iprot.readI64();
15322 
        else:
15323 
          iprot.skip(ftype)
15324 
      else:
15325 
        iprot.skip(ftype)
15326 
      iprot.readFieldEnd()
15327 
    iprot.readStructEnd()
15328 
 
15329 
  def write(self, oprot):
15330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15332 
      return
15333 
    oprot.writeStructBegin('addPrivateDealUser_args')
15334 
    if self.userId is not None:
15335 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15336 
      oprot.writeI64(self.userId)
15337 
      oprot.writeFieldEnd()
15338 
    oprot.writeFieldStop()
15339 
    oprot.writeStructEnd()
15340 
 
15341 
  def validate(self):
15342 
    return
15343 
 
15344 
 
15345 
  def __repr__(self):
15346 
    L = ['%s=%r' % (key, value)
15347 
      for key, value in self.__dict__.iteritems()]
15348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15349 
 
15350 
  def __eq__(self, other):
15351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15352 
 
15353 
  def __ne__(self, other):
15354 
    return not (self == other)
15355 
 
15356 
class addPrivateDealUser_result:
15357 
  """
15358 
  Attributes:
15359 
   - success
15360 
  """
15361 
 
15362 
  thrift_spec = (
15363 
    (0, TType.BOOL, 'success', None, None, ), # 0
15364 
  )
15365 
 
15366 
  def __init__(self, success=None,):
15367 
    self.success = success
15368 
 
15369 
  def read(self, iprot):
15370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15372 
      return
15373 
    iprot.readStructBegin()
15374 
    while True:
15375 
      (fname, ftype, fid) = iprot.readFieldBegin()
15376 
      if ftype == TType.STOP:
15377 
        break
15378 
      if fid == 0:
15379 
        if ftype == TType.BOOL:
15380 
          self.success = iprot.readBool();
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      else:
15384 
        iprot.skip(ftype)
15385 
      iprot.readFieldEnd()
15386 
    iprot.readStructEnd()
15387 
 
15388 
  def write(self, oprot):
15389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15391 
      return
15392 
    oprot.writeStructBegin('addPrivateDealUser_result')
15393 
    if self.success is not None:
15394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15395 
      oprot.writeBool(self.success)
15396 
      oprot.writeFieldEnd()
15397 
    oprot.writeFieldStop()
15398 
    oprot.writeStructEnd()
15399 
 
15400 
  def validate(self):
15401 
    return
15402 
 
15403 
 
15404 
  def __repr__(self):
15405 
    L = ['%s=%r' % (key, value)
15406 
      for key, value in self.__dict__.iteritems()]
15407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15408 
 
15409 
  def __eq__(self, other):
15410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15411 
 
15412 
  def __ne__(self, other):
15413 
    return not (self == other)
15414 
 
15415 
class changePrivateDealUserStatus_args:
15416 
  """
15417 
  Attributes:
15418 
   - userId
15419 
   - isActive
15420 
  """
15421 
 
15422 
  thrift_spec = (
15423 
    None, # 0
15424 
    (1, TType.I64, 'userId', None, None, ), # 1
15425 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15426 
  )
15427 
 
15428 
  def __init__(self, userId=None, isActive=None,):
15429 
    self.userId = userId
15430 
    self.isActive = isActive
15431 
 
15432 
  def read(self, iprot):
15433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15435 
      return
15436 
    iprot.readStructBegin()
15437 
    while True:
15438 
      (fname, ftype, fid) = iprot.readFieldBegin()
15439 
      if ftype == TType.STOP:
15440 
        break
15441 
      if fid == 1:
15442 
        if ftype == TType.I64:
15443 
          self.userId = iprot.readI64();
15444 
        else:
15445 
          iprot.skip(ftype)
15446 
      elif fid == 2:
15447 
        if ftype == TType.BOOL:
15448 
          self.isActive = iprot.readBool();
15449 
        else:
15450 
          iprot.skip(ftype)
15451 
      else:
15452 
        iprot.skip(ftype)
15453 
      iprot.readFieldEnd()
15454 
    iprot.readStructEnd()
15455 
 
15456 
  def write(self, oprot):
15457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15459 
      return
15460 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15461 
    if self.userId is not None:
15462 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15463 
      oprot.writeI64(self.userId)
15464 
      oprot.writeFieldEnd()
15465 
    if self.isActive is not None:
15466 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15467 
      oprot.writeBool(self.isActive)
15468 
      oprot.writeFieldEnd()
15469 
    oprot.writeFieldStop()
15470 
    oprot.writeStructEnd()
15471 
 
15472 
  def validate(self):
15473 
    return
15474 
 
15475 
 
15476 
  def __repr__(self):
15477 
    L = ['%s=%r' % (key, value)
15478 
      for key, value in self.__dict__.iteritems()]
15479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15480 
 
15481 
  def __eq__(self, other):
15482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15483 
 
15484 
  def __ne__(self, other):
15485 
    return not (self == other)
15486 
 
15487 
class changePrivateDealUserStatus_result:
15488 
  """
15489 
  Attributes:
15490 
   - success
15491 
  """
15492 
 
15493 
  thrift_spec = (
15494 
    (0, TType.BOOL, 'success', None, None, ), # 0
15495 
  )
15496 
 
15497 
  def __init__(self, success=None,):
15498 
    self.success = success
15499 
 
15500 
  def read(self, iprot):
15501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15503 
      return
15504 
    iprot.readStructBegin()
15505 
    while True:
15506 
      (fname, ftype, fid) = iprot.readFieldBegin()
15507 
      if ftype == TType.STOP:
15508 
        break
15509 
      if fid == 0:
15510 
        if ftype == TType.BOOL:
15511 
          self.success = iprot.readBool();
15512 
        else:
15513 
          iprot.skip(ftype)
15514 
      else:
15515 
        iprot.skip(ftype)
15516 
      iprot.readFieldEnd()
15517 
    iprot.readStructEnd()
15518 
 
15519 
  def write(self, oprot):
15520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15522 
      return
15523 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15524 
    if self.success is not None:
15525 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15526 
      oprot.writeBool(self.success)
15527 
      oprot.writeFieldEnd()
15528 
    oprot.writeFieldStop()
15529 
    oprot.writeStructEnd()
15530 
 
15531 
  def validate(self):
15532 
    return
15533 
 
15534 
 
15535 
  def __repr__(self):
15536 
    L = ['%s=%r' % (key, value)
15537 
      for key, value in self.__dict__.iteritems()]
15538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15539 
 
15540 
  def __eq__(self, other):
15541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15542 
 
15543 
  def __ne__(self, other):
15544 
    return not (self == other)
15545 
 
15546 
class getPrivateDealUser_args:
15547 
  """
15548 
  Attributes:
15549 
   - userId
15550 
  """
15551 
 
15552 
  thrift_spec = (
15553 
    None, # 0
15554 
    (1, TType.I64, 'userId', None, None, ), # 1
15555 
  )
15556 
 
15557 
  def __init__(self, userId=None,):
15558 
    self.userId = userId
15559 
 
15560 
  def read(self, iprot):
15561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15563 
      return
15564 
    iprot.readStructBegin()
15565 
    while True:
15566 
      (fname, ftype, fid) = iprot.readFieldBegin()
15567 
      if ftype == TType.STOP:
15568 
        break
15569 
      if fid == 1:
15570 
        if ftype == TType.I64:
15571 
          self.userId = iprot.readI64();
15572 
        else:
15573 
          iprot.skip(ftype)
15574 
      else:
15575 
        iprot.skip(ftype)
15576 
      iprot.readFieldEnd()
15577 
    iprot.readStructEnd()
15578 
 
15579 
  def write(self, oprot):
15580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15582 
      return
15583 
    oprot.writeStructBegin('getPrivateDealUser_args')
15584 
    if self.userId is not None:
15585 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15586 
      oprot.writeI64(self.userId)
15587 
      oprot.writeFieldEnd()
15588 
    oprot.writeFieldStop()
15589 
    oprot.writeStructEnd()
15590 
 
15591 
  def validate(self):
15592 
    return
15593 
 
15594 
 
15595 
  def __repr__(self):
15596 
    L = ['%s=%r' % (key, value)
15597 
      for key, value in self.__dict__.iteritems()]
15598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15599 
 
15600 
  def __eq__(self, other):
15601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15602 
 
15603 
  def __ne__(self, other):
15604 
    return not (self == other)
15605 
 
15606 
class getPrivateDealUser_result:
15607 
  """
15608 
  Attributes:
15609 
   - success
15610 
  """
15611 
 
15612 
  thrift_spec = (
15613 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15614 
  )
15615 
 
15616 
  def __init__(self, success=None,):
15617 
    self.success = success
15618 
 
15619 
  def read(self, iprot):
15620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15622 
      return
15623 
    iprot.readStructBegin()
15624 
    while True:
15625 
      (fname, ftype, fid) = iprot.readFieldBegin()
15626 
      if ftype == TType.STOP:
15627 
        break
15628 
      if fid == 0:
15629 
        if ftype == TType.STRUCT:
15630 
          self.success = PrivateDealUser()
15631 
          self.success.read(iprot)
15632 
        else:
15633 
          iprot.skip(ftype)
15634 
      else:
15635 
        iprot.skip(ftype)
15636 
      iprot.readFieldEnd()
15637 
    iprot.readStructEnd()
15638 
 
15639 
  def write(self, oprot):
15640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15642 
      return
15643 
    oprot.writeStructBegin('getPrivateDealUser_result')
15644 
    if self.success is not None:
15645 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15646 
      self.success.write(oprot)
15647 
      oprot.writeFieldEnd()
15648 
    oprot.writeFieldStop()
15649 
    oprot.writeStructEnd()
15650 
 
15651 
  def validate(self):
15652 
    return
15653 
 
15654 
 
15655 
  def __repr__(self):
15656 
    L = ['%s=%r' % (key, value)
15657 
      for key, value in self.__dict__.iteritems()]
15658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15659 
 
15660 
  def __eq__(self, other):
15661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15662 
 
15663 
  def __ne__(self, other):
15664 
    return not (self == other)
12696 amit.gupta 15665 
 
15666 
class registerCounter_args:
15667 
  """
15668 
  Attributes:
15669 
   - counter
15670 
   - userId
15671 
  """
15672 
 
15673 
  thrift_spec = (
15674 
    None, # 0
15675 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15676 
    (2, TType.I64, 'userId', None, None, ), # 2
15677 
  )
15678 
 
15679 
  def __init__(self, counter=None, userId=None,):
15680 
    self.counter = counter
15681 
    self.userId = userId
15682 
 
15683 
  def read(self, iprot):
15684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15686 
      return
15687 
    iprot.readStructBegin()
15688 
    while True:
15689 
      (fname, ftype, fid) = iprot.readFieldBegin()
15690 
      if ftype == TType.STOP:
15691 
        break
15692 
      if fid == 1:
15693 
        if ftype == TType.STRUCT:
15694 
          self.counter = Counter()
15695 
          self.counter.read(iprot)
15696 
        else:
15697 
          iprot.skip(ftype)
15698 
      elif fid == 2:
15699 
        if ftype == TType.I64:
15700 
          self.userId = iprot.readI64();
15701 
        else:
15702 
          iprot.skip(ftype)
15703 
      else:
15704 
        iprot.skip(ftype)
15705 
      iprot.readFieldEnd()
15706 
    iprot.readStructEnd()
15707 
 
15708 
  def write(self, oprot):
15709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15711 
      return
15712 
    oprot.writeStructBegin('registerCounter_args')
15713 
    if self.counter is not None:
15714 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
15715 
      self.counter.write(oprot)
15716 
      oprot.writeFieldEnd()
15717 
    if self.userId is not None:
15718 
      oprot.writeFieldBegin('userId', TType.I64, 2)
15719 
      oprot.writeI64(self.userId)
15720 
      oprot.writeFieldEnd()
15721 
    oprot.writeFieldStop()
15722 
    oprot.writeStructEnd()
15723 
 
15724 
  def validate(self):
15725 
    return
15726 
 
15727 
 
15728 
  def __repr__(self):
15729 
    L = ['%s=%r' % (key, value)
15730 
      for key, value in self.__dict__.iteritems()]
15731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15732 
 
15733 
  def __eq__(self, other):
15734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15735 
 
15736 
  def __ne__(self, other):
15737 
    return not (self == other)
15738 
 
15739 
class registerCounter_result:
15740 
  """
15741 
  Attributes:
15742 
   - success
15743 
  """
15744 
 
15745 
  thrift_spec = (
15746 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
15747 
  )
15748 
 
15749 
  def __init__(self, success=None,):
15750 
    self.success = success
15751 
 
15752 
  def read(self, iprot):
15753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15755 
      return
15756 
    iprot.readStructBegin()
15757 
    while True:
15758 
      (fname, ftype, fid) = iprot.readFieldBegin()
15759 
      if ftype == TType.STOP:
15760 
        break
15761 
      if fid == 0:
15762 
        if ftype == TType.MAP:
15763 
          self.success = {}
15764 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
15765 
          for _i229 in xrange(_size225):
15766 
            _key230 = iprot.readString();
15767 
            _val231 = iprot.readString();
15768 
            self.success[_key230] = _val231
15769 
          iprot.readMapEnd()
15770 
        else:
15771 
          iprot.skip(ftype)
15772 
      else:
15773 
        iprot.skip(ftype)
15774 
      iprot.readFieldEnd()
15775 
    iprot.readStructEnd()
15776 
 
15777 
  def write(self, oprot):
15778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15780 
      return
15781 
    oprot.writeStructBegin('registerCounter_result')
15782 
    if self.success is not None:
15783 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15784 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
15785 
      for kiter232,viter233 in self.success.items():
15786 
        oprot.writeString(kiter232)
15787 
        oprot.writeString(viter233)
15788 
      oprot.writeMapEnd()
15789 
      oprot.writeFieldEnd()
15790 
    oprot.writeFieldStop()
15791 
    oprot.writeStructEnd()
15792 
 
15793 
  def validate(self):
15794 
    return
15795 
 
15796 
 
15797 
  def __repr__(self):
15798 
    L = ['%s=%r' % (key, value)
15799 
      for key, value in self.__dict__.iteritems()]
15800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15801 
 
15802 
  def __eq__(self, other):
15803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15804 
 
15805 
  def __ne__(self, other):
15806 
    return not (self == other)
12722 amit.gupta 15807 
 
15808 
class searchCounter_args:
15809 
  """
15810 
  Attributes:
15811 
   - type1
15812 
   - searchString
15813 
  """
15814 
 
15815 
  thrift_spec = (
15816 
    None, # 0
15817 
    (1, TType.STRING, 'type1', None, None, ), # 1
15818 
    (2, TType.STRING, 'searchString', None, None, ), # 2
15819 
  )
15820 
 
15821 
  def __init__(self, type1=None, searchString=None,):
15822 
    self.type1 = type1
15823 
    self.searchString = searchString
15824 
 
15825 
  def read(self, iprot):
15826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15828 
      return
15829 
    iprot.readStructBegin()
15830 
    while True:
15831 
      (fname, ftype, fid) = iprot.readFieldBegin()
15832 
      if ftype == TType.STOP:
15833 
        break
15834 
      if fid == 1:
15835 
        if ftype == TType.STRING:
15836 
          self.type1 = iprot.readString();
15837 
        else:
15838 
          iprot.skip(ftype)
15839 
      elif fid == 2:
15840 
        if ftype == TType.STRING:
15841 
          self.searchString = iprot.readString();
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      else:
15845 
        iprot.skip(ftype)
15846 
      iprot.readFieldEnd()
15847 
    iprot.readStructEnd()
15848 
 
15849 
  def write(self, oprot):
15850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15852 
      return
15853 
    oprot.writeStructBegin('searchCounter_args')
15854 
    if self.type1 is not None:
15855 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
15856 
      oprot.writeString(self.type1)
15857 
      oprot.writeFieldEnd()
15858 
    if self.searchString is not None:
15859 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
15860 
      oprot.writeString(self.searchString)
15861 
      oprot.writeFieldEnd()
15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
15880 
class searchCounter_result:
15881 
  """
15882 
  Attributes:
15883 
   - success
15884 
  """
15885 
 
15886 
  thrift_spec = (
15887 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
15888 
  )
15889 
 
15890 
  def __init__(self, success=None,):
15891 
    self.success = success
15892 
 
15893 
  def read(self, iprot):
15894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15896 
      return
15897 
    iprot.readStructBegin()
15898 
    while True:
15899 
      (fname, ftype, fid) = iprot.readFieldBegin()
15900 
      if ftype == TType.STOP:
15901 
        break
15902 
      if fid == 0:
15903 
        if ftype == TType.LIST:
15904 
          self.success = []
15905 
          (_etype237, _size234) = iprot.readListBegin()
15906 
          for _i238 in xrange(_size234):
15907 
            _elem239 = Counter()
15908 
            _elem239.read(iprot)
15909 
            self.success.append(_elem239)
15910 
          iprot.readListEnd()
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      else:
15914 
        iprot.skip(ftype)
15915 
      iprot.readFieldEnd()
15916 
    iprot.readStructEnd()
15917 
 
15918 
  def write(self, oprot):
15919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15921 
      return
15922 
    oprot.writeStructBegin('searchCounter_result')
15923 
    if self.success is not None:
15924 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15925 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15926 
      for iter240 in self.success:
15927 
        iter240.write(oprot)
15928 
      oprot.writeListEnd()
15929 
      oprot.writeFieldEnd()
15930 
    oprot.writeFieldStop()
15931 
    oprot.writeStructEnd()
15932 
 
15933 
  def validate(self):
15934 
    return
15935 
 
15936 
 
15937 
  def __repr__(self):
15938 
    L = ['%s=%r' % (key, value)
15939 
      for key, value in self.__dict__.iteritems()]
15940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15941 
 
15942 
  def __eq__(self, other):
15943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15944 
 
15945 
  def __ne__(self, other):
15946 
    return not (self == other)
15947 
 
15948 
class getAllUsersByCounter_args:
15949 
  """
15950 
  Attributes:
15951 
   - counterId
15952 
  """
15953 
 
15954 
  thrift_spec = (
15955 
    None, # 0
15956 
    (1, TType.I64, 'counterId', None, None, ), # 1
15957 
  )
15958 
 
15959 
  def __init__(self, counterId=None,):
15960 
    self.counterId = counterId
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 == 1:
15972 
        if ftype == TType.I64:
15973 
          self.counterId = iprot.readI64();
15974 
        else:
15975 
          iprot.skip(ftype)
15976 
      else:
15977 
        iprot.skip(ftype)
15978 
      iprot.readFieldEnd()
15979 
    iprot.readStructEnd()
15980 
 
15981 
  def write(self, oprot):
15982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15984 
      return
15985 
    oprot.writeStructBegin('getAllUsersByCounter_args')
15986 
    if self.counterId is not None:
15987 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
15988 
      oprot.writeI64(self.counterId)
15989 
      oprot.writeFieldEnd()
15990 
    oprot.writeFieldStop()
15991 
    oprot.writeStructEnd()
15992 
 
15993 
  def validate(self):
15994 
    return
15995 
 
15996 
 
15997 
  def __repr__(self):
15998 
    L = ['%s=%r' % (key, value)
15999 
      for key, value in self.__dict__.iteritems()]
16000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16001 
 
16002 
  def __eq__(self, other):
16003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16004 
 
16005 
  def __ne__(self, other):
16006 
    return not (self == other)
16007 
 
16008 
class getAllUsersByCounter_result:
16009 
  """
16010 
  Attributes:
16011 
   - success
16012 
  """
16013 
 
16014 
  thrift_spec = (
16015 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16016 
  )
16017 
 
16018 
  def __init__(self, success=None,):
16019 
    self.success = success
16020 
 
16021 
  def read(self, iprot):
16022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16024 
      return
16025 
    iprot.readStructBegin()
16026 
    while True:
16027 
      (fname, ftype, fid) = iprot.readFieldBegin()
16028 
      if ftype == TType.STOP:
16029 
        break
16030 
      if fid == 0:
16031 
        if ftype == TType.LIST:
16032 
          self.success = []
16033 
          (_etype244, _size241) = iprot.readListBegin()
16034 
          for _i245 in xrange(_size241):
16035 
            _elem246 = User()
16036 
            _elem246.read(iprot)
16037 
            self.success.append(_elem246)
16038 
          iprot.readListEnd()
16039 
        else:
16040 
          iprot.skip(ftype)
16041 
      else:
16042 
        iprot.skip(ftype)
16043 
      iprot.readFieldEnd()
16044 
    iprot.readStructEnd()
16045 
 
16046 
  def write(self, oprot):
16047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16049 
      return
16050 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16051 
    if self.success is not None:
16052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16054 
      for iter247 in self.success:
16055 
        iter247.write(oprot)
16056 
      oprot.writeListEnd()
16057 
      oprot.writeFieldEnd()
16058 
    oprot.writeFieldStop()
16059 
    oprot.writeStructEnd()
16060 
 
16061 
  def validate(self):
16062 
    return
16063 
 
16064 
 
16065 
  def __repr__(self):
16066 
    L = ['%s=%r' % (key, value)
16067 
      for key, value in self.__dict__.iteritems()]
16068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16069 
 
16070 
  def __eq__(self, other):
16071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16072 
 
16073 
  def __ne__(self, other):
16074 
    return not (self == other)
15251 manish.sha 16075 
 
16076 
class getActiveAccessTokenForUser_args:
16077 
  """
16078 
  Attributes:
16079 
   - userId
16080 
   - source
16081 
  """
16082 
 
16083 
  thrift_spec = (
16084 
    None, # 0
16085 
    (1, TType.I64, 'userId', None, None, ), # 1
16086 
    (2, TType.STRING, 'source', None, None, ), # 2
16087 
  )
16088 
 
16089 
  def __init__(self, userId=None, source=None,):
16090 
    self.userId = userId
16091 
    self.source = source
16092 
 
16093 
  def read(self, iprot):
16094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16096 
      return
16097 
    iprot.readStructBegin()
16098 
    while True:
16099 
      (fname, ftype, fid) = iprot.readFieldBegin()
16100 
      if ftype == TType.STOP:
16101 
        break
16102 
      if fid == 1:
16103 
        if ftype == TType.I64:
16104 
          self.userId = iprot.readI64();
16105 
        else:
16106 
          iprot.skip(ftype)
16107 
      elif fid == 2:
16108 
        if ftype == TType.STRING:
16109 
          self.source = iprot.readString();
16110 
        else:
16111 
          iprot.skip(ftype)
16112 
      else:
16113 
        iprot.skip(ftype)
16114 
      iprot.readFieldEnd()
16115 
    iprot.readStructEnd()
16116 
 
16117 
  def write(self, oprot):
16118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16120 
      return
16121 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16122 
    if self.userId is not None:
16123 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16124 
      oprot.writeI64(self.userId)
16125 
      oprot.writeFieldEnd()
16126 
    if self.source is not None:
16127 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16128 
      oprot.writeString(self.source)
16129 
      oprot.writeFieldEnd()
16130 
    oprot.writeFieldStop()
16131 
    oprot.writeStructEnd()
16132 
 
16133 
  def validate(self):
16134 
    return
16135 
 
16136 
 
16137 
  def __repr__(self):
16138 
    L = ['%s=%r' % (key, value)
16139 
      for key, value in self.__dict__.iteritems()]
16140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16141 
 
16142 
  def __eq__(self, other):
16143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16144 
 
16145 
  def __ne__(self, other):
16146 
    return not (self == other)
16147 
 
16148 
class getActiveAccessTokenForUser_result:
16149 
  """
16150 
  Attributes:
16151 
   - success
16152 
  """
16153 
 
16154 
  thrift_spec = (
16155 
    (0, TType.STRING, 'success', None, None, ), # 0
16156 
  )
16157 
 
16158 
  def __init__(self, success=None,):
16159 
    self.success = success
16160 
 
16161 
  def read(self, iprot):
16162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16164 
      return
16165 
    iprot.readStructBegin()
16166 
    while True:
16167 
      (fname, ftype, fid) = iprot.readFieldBegin()
16168 
      if ftype == TType.STOP:
16169 
        break
16170 
      if fid == 0:
16171 
        if ftype == TType.STRING:
16172 
          self.success = iprot.readString();
16173 
        else:
16174 
          iprot.skip(ftype)
16175 
      else:
16176 
        iprot.skip(ftype)
16177 
      iprot.readFieldEnd()
16178 
    iprot.readStructEnd()
16179 
 
16180 
  def write(self, oprot):
16181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16183 
      return
16184 
    oprot.writeStructBegin('getActiveAccessTokenForUser_result')
16185 
    if self.success is not None:
16186 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16187 
      oprot.writeString(self.success)
16188 
      oprot.writeFieldEnd()
16189 
    oprot.writeFieldStop()
16190 
    oprot.writeStructEnd()
16191 
 
16192 
  def validate(self):
16193 
    return
16194 
 
16195 
 
16196 
  def __repr__(self):
16197 
    L = ['%s=%r' % (key, value)
16198 
      for key, value in self.__dict__.iteritems()]
16199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16200 
 
16201 
  def __eq__(self, other):
16202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16203 
 
16204 
  def __ne__(self, other):
16205 
    return not (self == other)
16206 
 
16207 
class validateAccessToken_args:
16208 
  """
16209 
  Attributes:
16210 
   - accessToken
16211 
  """
16212 
 
16213 
  thrift_spec = (
16214 
    None, # 0
16215 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16216 
  )
16217 
 
16218 
  def __init__(self, accessToken=None,):
16219 
    self.accessToken = accessToken
16220 
 
16221 
  def read(self, iprot):
16222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16224 
      return
16225 
    iprot.readStructBegin()
16226 
    while True:
16227 
      (fname, ftype, fid) = iprot.readFieldBegin()
16228 
      if ftype == TType.STOP:
16229 
        break
16230 
      if fid == 1:
16231 
        if ftype == TType.STRING:
16232 
          self.accessToken = iprot.readString();
16233 
        else:
16234 
          iprot.skip(ftype)
16235 
      else:
16236 
        iprot.skip(ftype)
16237 
      iprot.readFieldEnd()
16238 
    iprot.readStructEnd()
16239 
 
16240 
  def write(self, oprot):
16241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16243 
      return
16244 
    oprot.writeStructBegin('validateAccessToken_args')
16245 
    if self.accessToken is not None:
16246 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16247 
      oprot.writeString(self.accessToken)
16248 
      oprot.writeFieldEnd()
16249 
    oprot.writeFieldStop()
16250 
    oprot.writeStructEnd()
16251 
 
16252 
  def validate(self):
16253 
    return
16254 
 
16255 
 
16256 
  def __repr__(self):
16257 
    L = ['%s=%r' % (key, value)
16258 
      for key, value in self.__dict__.iteritems()]
16259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16260 
 
16261 
  def __eq__(self, other):
16262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16263 
 
16264 
  def __ne__(self, other):
16265 
    return not (self == other)
16266 
 
16267 
class validateAccessToken_result:
16268 
  """
16269 
  Attributes:
16270 
   - success
16271 
  """
16272 
 
16273 
  thrift_spec = (
16274 
    (0, TType.BOOL, 'success', None, None, ), # 0
16275 
  )
16276 
 
16277 
  def __init__(self, success=None,):
16278 
    self.success = success
16279 
 
16280 
  def read(self, iprot):
16281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16283 
      return
16284 
    iprot.readStructBegin()
16285 
    while True:
16286 
      (fname, ftype, fid) = iprot.readFieldBegin()
16287 
      if ftype == TType.STOP:
16288 
        break
16289 
      if fid == 0:
16290 
        if ftype == TType.BOOL:
16291 
          self.success = iprot.readBool();
16292 
        else:
16293 
          iprot.skip(ftype)
16294 
      else:
16295 
        iprot.skip(ftype)
16296 
      iprot.readFieldEnd()
16297 
    iprot.readStructEnd()
16298 
 
16299 
  def write(self, oprot):
16300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16302 
      return
16303 
    oprot.writeStructBegin('validateAccessToken_result')
16304 
    if self.success is not None:
16305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16306 
      oprot.writeBool(self.success)
16307 
      oprot.writeFieldEnd()
16308 
    oprot.writeFieldStop()
16309 
    oprot.writeStructEnd()
16310 
 
16311 
  def validate(self):
16312 
    return
16313 
 
16314 
 
16315 
  def __repr__(self):
16316 
    L = ['%s=%r' % (key, value)
16317 
      for key, value in self.__dict__.iteritems()]
16318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16319 
 
16320 
  def __eq__(self, other):
16321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16322 
 
16323 
  def __ne__(self, other):
16324 
    return not (self == other)
17782 amit.gupta 16325 
 
16326 
class addItemsToCart_args:
16327 
  """
16328 
  Attributes:
16329 
   - cartId
16330 
   - itemQty
16331 
   - couponCode
16332 
  """
16333 
 
16334 
  thrift_spec = (
16335 
    None, # 0
16336 
    (1, TType.I64, 'cartId', None, None, ), # 1
16337 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16338 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16339 
  )
16340 
 
16341 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16342 
    self.cartId = cartId
16343 
    self.itemQty = itemQty
16344 
    self.couponCode = couponCode
16345 
 
16346 
  def read(self, iprot):
16347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16349 
      return
16350 
    iprot.readStructBegin()
16351 
    while True:
16352 
      (fname, ftype, fid) = iprot.readFieldBegin()
16353 
      if ftype == TType.STOP:
16354 
        break
16355 
      if fid == 1:
16356 
        if ftype == TType.I64:
16357 
          self.cartId = iprot.readI64();
16358 
        else:
16359 
          iprot.skip(ftype)
16360 
      elif fid == 2:
16361 
        if ftype == TType.LIST:
16362 
          self.itemQty = []
16363 
          (_etype251, _size248) = iprot.readListBegin()
16364 
          for _i252 in xrange(_size248):
16365 
            _elem253 = ItemQuantity()
16366 
            _elem253.read(iprot)
16367 
            self.itemQty.append(_elem253)
16368 
          iprot.readListEnd()
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      elif fid == 3:
16372 
        if ftype == TType.STRING:
16373 
          self.couponCode = iprot.readString();
16374 
        else:
16375 
          iprot.skip(ftype)
16376 
      else:
16377 
        iprot.skip(ftype)
16378 
      iprot.readFieldEnd()
16379 
    iprot.readStructEnd()
16380 
 
16381 
  def write(self, oprot):
16382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16384 
      return
16385 
    oprot.writeStructBegin('addItemsToCart_args')
16386 
    if self.cartId is not None:
16387 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16388 
      oprot.writeI64(self.cartId)
16389 
      oprot.writeFieldEnd()
16390 
    if self.itemQty is not None:
16391 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16392 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16393 
      for iter254 in self.itemQty:
16394 
        iter254.write(oprot)
16395 
      oprot.writeListEnd()
16396 
      oprot.writeFieldEnd()
16397 
    if self.couponCode is not None:
16398 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16399 
      oprot.writeString(self.couponCode)
16400 
      oprot.writeFieldEnd()
16401 
    oprot.writeFieldStop()
16402 
    oprot.writeStructEnd()
16403 
 
16404 
  def validate(self):
16405 
    return
16406 
 
16407 
 
16408 
  def __repr__(self):
16409 
    L = ['%s=%r' % (key, value)
16410 
      for key, value in self.__dict__.iteritems()]
16411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16412 
 
16413 
  def __eq__(self, other):
16414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16415 
 
16416 
  def __ne__(self, other):
16417 
    return not (self == other)
16418 
 
16419 
class addItemsToCart_result:
16420 
  """
16421 
  Attributes:
16422 
   - success
16423 
  """
16424 
 
16425 
  thrift_spec = (
16426 
    (0, TType.BOOL, 'success', None, None, ), # 0
16427 
  )
16428 
 
16429 
  def __init__(self, success=None,):
16430 
    self.success = success
16431 
 
16432 
  def read(self, iprot):
16433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16435 
      return
16436 
    iprot.readStructBegin()
16437 
    while True:
16438 
      (fname, ftype, fid) = iprot.readFieldBegin()
16439 
      if ftype == TType.STOP:
16440 
        break
16441 
      if fid == 0:
16442 
        if ftype == TType.BOOL:
16443 
          self.success = iprot.readBool();
16444 
        else:
16445 
          iprot.skip(ftype)
16446 
      else:
16447 
        iprot.skip(ftype)
16448 
      iprot.readFieldEnd()
16449 
    iprot.readStructEnd()
16450 
 
16451 
  def write(self, oprot):
16452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16454 
      return
16455 
    oprot.writeStructBegin('addItemsToCart_result')
16456 
    if self.success is not None:
16457 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16458 
      oprot.writeBool(self.success)
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)
16477 
 
16478 
class validateCartNew_args:
16479 
  """
16480 
  Attributes:
16481 
   - cartId
16482 
   - pinCode
16483 
   - sourceId
16484 
  """
16485 
 
16486 
  thrift_spec = (
16487 
    None, # 0
16488 
    (1, TType.I64, 'cartId', None, None, ), # 1
16489 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16490 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16491 
  )
16492 
 
16493 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16494 
    self.cartId = cartId
16495 
    self.pinCode = pinCode
16496 
    self.sourceId = sourceId
16497 
 
16498 
  def read(self, iprot):
16499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16501 
      return
16502 
    iprot.readStructBegin()
16503 
    while True:
16504 
      (fname, ftype, fid) = iprot.readFieldBegin()
16505 
      if ftype == TType.STOP:
16506 
        break
16507 
      if fid == 1:
16508 
        if ftype == TType.I64:
16509 
          self.cartId = iprot.readI64();
16510 
        else:
16511 
          iprot.skip(ftype)
16512 
      elif fid == 2:
16513 
        if ftype == TType.STRING:
16514 
          self.pinCode = iprot.readString();
16515 
        else:
16516 
          iprot.skip(ftype)
16517 
      elif fid == 3:
16518 
        if ftype == TType.I64:
16519 
          self.sourceId = iprot.readI64();
16520 
        else:
16521 
          iprot.skip(ftype)
16522 
      else:
16523 
        iprot.skip(ftype)
16524 
      iprot.readFieldEnd()
16525 
    iprot.readStructEnd()
16526 
 
16527 
  def write(self, oprot):
16528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16530 
      return
16531 
    oprot.writeStructBegin('validateCartNew_args')
16532 
    if self.cartId is not None:
16533 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16534 
      oprot.writeI64(self.cartId)
16535 
      oprot.writeFieldEnd()
16536 
    if self.pinCode is not None:
16537 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16538 
      oprot.writeString(self.pinCode)
16539 
      oprot.writeFieldEnd()
16540 
    if self.sourceId is not None:
16541 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16542 
      oprot.writeI64(self.sourceId)
16543 
      oprot.writeFieldEnd()
16544 
    oprot.writeFieldStop()
16545 
    oprot.writeStructEnd()
16546 
 
16547 
  def validate(self):
16548 
    return
16549 
 
16550 
 
16551 
  def __repr__(self):
16552 
    L = ['%s=%r' % (key, value)
16553 
      for key, value in self.__dict__.iteritems()]
16554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16555 
 
16556 
  def __eq__(self, other):
16557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16558 
 
16559 
  def __ne__(self, other):
16560 
    return not (self == other)
16561 
 
16562 
class validateCartNew_result:
16563 
  """
16564 
  Attributes:
16565 
   - success
16566 
  """
16567 
 
16568 
  thrift_spec = (
16569 
    (0, TType.STRING, 'success', None, None, ), # 0
16570 
  )
16571 
 
16572 
  def __init__(self, success=None,):
16573 
    self.success = success
16574 
 
16575 
  def read(self, iprot):
16576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16578 
      return
16579 
    iprot.readStructBegin()
16580 
    while True:
16581 
      (fname, ftype, fid) = iprot.readFieldBegin()
16582 
      if ftype == TType.STOP:
16583 
        break
16584 
      if fid == 0:
16585 
        if ftype == TType.STRING:
16586 
          self.success = iprot.readString();
16587 
        else:
16588 
          iprot.skip(ftype)
16589 
      else:
16590 
        iprot.skip(ftype)
16591 
      iprot.readFieldEnd()
16592 
    iprot.readStructEnd()
16593 
 
16594 
  def write(self, oprot):
16595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16597 
      return
16598 
    oprot.writeStructBegin('validateCartNew_result')
16599 
    if self.success is not None:
16600 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16601 
      oprot.writeString(self.success)
16602 
      oprot.writeFieldEnd()
16603 
    oprot.writeFieldStop()
16604 
    oprot.writeStructEnd()
16605 
 
16606 
  def validate(self):
16607 
    return
16608 
 
16609 
 
16610 
  def __repr__(self):
16611 
    L = ['%s=%r' % (key, value)
16612 
      for key, value in self.__dict__.iteritems()]
16613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16614 
 
16615 
  def __eq__(self, other):
16616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16617 
 
16618 
  def __ne__(self, other):
16619 
    return not (self == other)