Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
5326 rajveer 37 
  def getUserByCartId(self, cartId):
38 
    """
39 
    Parameters:
40 
     - cartId
41 
    """
42 
    pass
43 
 
1491 vikas 44 
  def getUserByEmail(self, email):
45 
    """
46 
    Parameters:
47 
     - email
48 
    """
49 
    pass
50 
 
3032 mandeep.dh 51 
  def getUserByMobileNumber(self, mobileNumber):
52 
    """
53 
    Parameters:
54 
     - mobileNumber
55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def createUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def updateUser(self, user):
94 ashish 66 
    """
67 
    Parameters:
559 chandransh 68 
     - user
94 ashish 69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def authenticateUser(self, email, password):
94 ashish 73 
    """
74 
    Parameters:
75 
     - email
76 
     - password
77 
    """
78 
    pass
79 
 
80 
  def userExists(self, email):
81 
    """
82 
    Parameters:
83 
     - email
84 
    """
85 
    pass
86 
 
567 rajveer 87 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 88 
    """
89 
    Parameters:
90 
     - userId
91 
     - address
513 rajveer 92 
     - setDefault
94 ashish 93 
    """
94 
    pass
95 
 
96 
  def removeAddressForUser(self, userid, addressId):
97 
    """
98 
    Parameters:
99 
     - userid
100 
     - addressId
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedIn(self, userId, timestamp):
105 
    """
106 
    Parameters:
107 
     - userId
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def setUserAsLoggedOut(self, userid, timestamp):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - timestamp
117 
    """
118 
    pass
119 
 
504 rajveer 120 
  def setDefaultAddress(self, userid, addressId):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - addressId
125 
    """
126 
    pass
127 
 
594 rajveer 128 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 129 
    """
130 
    Parameters:
131 
     - userid
594 rajveer 132 
     - oldPassword
133 
     - newPassword
94 ashish 134 
    """
135 
    pass
136 
 
884 rajveer 137 
  def forgotPassword(self, email, newPassword):
581 rajveer 138 
    """
139 
    Parameters:
140 
     - email
884 rajveer 141 
     - newPassword
581 rajveer 142 
    """
143 
    pass
144 
 
594 rajveer 145 
  def getAllAddressesForUser(self, userId):
146 
    """
147 
    Parameters:
148 
     - userId
149 
    """
150 
    pass
151 
 
1894 vikas 152 
  def getAddressById(self, addressId):
153 
    """
154 
    Parameters:
155 
     - addressId
156 
    """
157 
    pass
158 
 
594 rajveer 159 
  def getDefaultAddressId(self, userId):
160 
    """
161 
    Parameters:
162 
     - userId
163 
    """
164 
    pass
165 
 
785 rajveer 166 
  def getDefaultPincode(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
1274 varun.gupt 173 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
174 
    """
175 
    Parameters:
176 
     - userId
177 
     - replyTo
178 
     - communicationType
179 
     - orderId
180 
     - airwaybillNo
181 
     - productName
182 
     - subject
183 
     - message
184 
    """
185 
    pass
186 
 
1590 varun.gupt 187 
  def getUserCommunicationById(self, id):
188 
    """
189 
    Parameters:
190 
     - id
191 
    """
192 
    pass
193 
 
194 
  def getUserCommunicationByUser(self, userId):
195 
    """
196 
    Parameters:
197 
     - userId
198 
    """
199 
    pass
200 
 
201 
  def getAllUserCommunications(self, ):
202 
    pass
203 
 
5407 amar.kumar 204 
  def removeUserCommunication(self, id):
205 
    """
206 
    Parameters:
207 
     - id
208 
    """
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def getCurrentCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCart(self, cartId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - cartId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - from_time
336 
     - to_time
337 
     - status
94 ashish 338 
    """
339 
    pass
340 
 
3557 rajveer 341 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
130 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
345 
     - itemId
346 
     - quantity
3557 rajveer 347 
     - sourceId
130 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def deleteItemFromCart(self, cartId, itemId):
352 
    """
353 
    Parameters:
354 
     - cartId
355 
     - itemId
356 
    """
357 
    pass
130 ashish 358 
 
559 chandransh 359 
  def addAddressToCart(self, cartId, addressId):
360 
    """
361 
    Parameters:
362 
     - cartId
363 
     - addressId
364 
    """
365 
    pass
366 
 
5553 rajveer 367 
  def addStoreToCart(self, cartId, storeId):
368 
    """
369 
    Parameters:
370 
     - cartId
371 
     - storeId
372 
    """
373 
    pass
374 
 
6922 anupam.sin 375 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 376 
    """
377 
    Parameters:
6922 anupam.sin 378 
     - cart
1976 varun.gupt 379 
     - couponCode
380 
    """
381 
    pass
382 
 
383 
  def removeCoupon(self, cartId):
384 
    """
385 
    Parameters:
386 
     - cartId
387 
    """
388 
    pass
389 
 
3554 varun.gupt 390 
  def deleteDiscountsFromCart(self, cartId):
391 
    """
392 
    Deletes all the discounts associated with the cart
393 
 
394 
    Parameters:
395 
     - cartId
396 
    """
397 
    pass
398 
 
399 
  def saveDiscounts(self, discounts):
400 
    """
401 
    Accepts a list of thrift objects of Discount type and saves them
402 
 
403 
    Parameters:
404 
     - discounts
405 
    """
406 
    pass
407 
 
11526 amit.gupta 408 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 409 
    """
690 chandransh 410 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 411 
 
559 chandransh 412 
    Parameters:
413 
     - cartId
2815 vikas 414 
     - sessionSource
415 
     - sessionStartTime
3858 vikas 416 
     - firstSource
417 
     - firstSourceTime
5326 rajveer 418 
     - userId
6389 rajveer 419 
     - schemeId
11526 amit.gupta 420 
     - orderSource
559 chandransh 421 
    """
422 
    pass
423 
 
3557 rajveer 424 
  def validateCart(self, cartId, sourceId):
559 chandransh 425 
    """
690 chandransh 426 
    Validates that:
427 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 428 
    2. All of the lines in the cart are active items.
690 chandransh 429 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 430 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 431 
 
559 chandransh 432 
    Parameters:
433 
     - cartId
3557 rajveer 434 
     - sourceId
559 chandransh 435 
    """
436 
    pass
437 
 
11980 amit.gupta 438 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
439 
    """
440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
442 
    2. All of the lines in the cart are active items.
443 
    3. The estimate for any of the lines in cart doesn't change.
444 
    If all three are true, returns empty string; else returns appropriate message.
445 
 
446 
    Parameters:
447 
     - cartId
448 
     - sourceId
449 
     - dealCoupon
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 454 
    """
690 chandransh 455 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 456 
 
575 chandransh 457 
    Parameters:
690 chandransh 458 
     - fromCartId
459 
     - toCartId
460 
    """
461 
    pass
462 
 
463 
  def checkOut(self, cartId):
464 
    """
465 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 466 
 
690 chandransh 467 
    Parameters:
575 chandransh 468 
     - cartId
469 
    """
470 
    pass
471 
 
690 chandransh 472 
  def resetCart(self, cartId, items):
559 chandransh 473 
    """
690 chandransh 474 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
475 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 476 
 
559 chandransh 477 
    Parameters:
690 chandransh 478 
     - cartId
479 
     - items
559 chandransh 480 
    """
481 
    pass
482 
 
2981 rajveer 483 
  def getUserCount(self, userType):
559 chandransh 484 
    """
2981 rajveer 485 
    Returns number of registered users.
486 
    If userType = null, then it returns count of all users, including anonymous
487 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
488 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 489 
 
559 chandransh 490 
    Parameters:
2981 rajveer 491 
     - userType
559 chandransh 492 
    """
493 
    pass
494 
 
2981 rajveer 495 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 496 
    """
2981 rajveer 497 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
498 
    If any of startDate or endDate is -1, then that filter is ignored.
499 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 500 
 
501 
 
559 chandransh 502 
    Parameters:
2981 rajveer 503 
     - userType
504 
     - startDate
505 
     - endDate
559 chandransh 506 
    """
507 
    pass
508 
 
2981 rajveer 509 
  def getMyResearchItems(self, userId):
559 chandransh 510 
    """
2981 rajveer 511 
    Returns list of item ids in myresearch for the user
3431 rajveer 512 
 
559 chandransh 513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
2981 rajveer 518 
  def updateMyResearch(self, userId, itemId):
559 chandransh 519 
    """
2981 rajveer 520 
    add item to my research for a user
3431 rajveer 521 
 
559 chandransh 522 
    Parameters:
2981 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
2981 rajveer 528 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 529 
    """
2981 rajveer 530 
    delete item from my research for a user
3431 rajveer 531 
 
1596 ankur.sing 532 
    Parameters:
2981 rajveer 533 
     - userId
534 
     - itemId
1596 ankur.sing 535 
    """
536 
    pass
559 chandransh 537 
 
2981 rajveer 538 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 539 
    """
2981 rajveer 540 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 541 
 
1673 ankur.sing 542 
    Parameters:
2981 rajveer 543 
     - userId
1673 ankur.sing 544 
    """
545 
    pass
1596 ankur.sing 546 
 
2981 rajveer 547 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 548 
    """
2981 rajveer 549 
    add item to browse history for a user
3431 rajveer 550 
 
2642 varun.gupt 551 
    Parameters:
2981 rajveer 552 
     - userId
553 
     - itemId
2642 varun.gupt 554 
    """
555 
    pass
1673 ankur.sing 556 
 
3385 varun.gupt 557 
  def getCartsWithCouponCount(self, couponCode):
558 
    """
559 
    Returns count of Carts with given coupon applied
3431 rajveer 560 
 
3385 varun.gupt 561 
    Parameters:
562 
     - couponCode
563 
    """
564 
    pass
2642 varun.gupt 565 
 
3499 mandeep.dh 566 
  def increaseTrustLevel(self, userId, trustLevelDelta):
567 
    """
568 
    Updates COD trust level of a user
3385 varun.gupt 569 
 
3499 mandeep.dh 570 
    Parameters:
571 
     - userId
572 
     - trustLevelDelta
573 
    """
574 
    pass
575 
 
5407 amar.kumar 576 
  def getTrustLevel(self, userId):
577 
    """
578 
    Get trust level of a user
579 
 
580 
    Parameters:
581 
     - userId
582 
    """
583 
    pass
584 
 
4668 varun.gupt 585 
  def showCODOption(self, cartId, sourceId, pincode):
586 
    """
587 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 588 
 
4668 varun.gupt 589 
    Parameters:
590 
     - cartId
591 
     - sourceId
592 
     - pincode
593 
    """
594 
    pass
595 
 
5623 anupam.sin 596 
  def getUserEmails(self, startDate, endDate):
597 
    """
598 
    Get email addresses for users activated within a given date range
4668 varun.gupt 599 
 
5623 anupam.sin 600 
    Parameters:
601 
     - startDate
602 
     - endDate
603 
    """
604 
    pass
605 
 
9299 kshitij.so 606 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 607 
    """
608 
    Mark a cart lineitem as insured. Returns true/false.
609 
 
610 
    Parameters:
611 
     - itemId
612 
     - cartId
613 
     - toInsure
9299 kshitij.so 614 
     - insurerType
6903 anupam.sin 615 
    """
616 
    pass
617 
 
618 
  def cancelInsurance(self, cartId):
619 
    """
620 
    Cancel insurance for all items in the cart
621 
 
622 
    Parameters:
623 
     - cartId
624 
    """
625 
    pass
626 
 
627 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
628 
    """
629 
    Stores insurance specific details like date of birth and guardianName
630 
 
631 
    Parameters:
632 
     - addressId
633 
     - dob
634 
     - guardianName
635 
    """
636 
    pass
637 
 
638 
  def isInsuranceDetailPresent(self, addressId):
639 
    """
640 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
641 
 
642 
    Parameters:
643 
     - addressId
644 
    """
645 
    pass
646 
 
9791 rajveer 647 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 648 
    """
9791 rajveer 649 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 650 
 
6821 amar.kumar 651 
    Parameters:
652 
     - startDate
653 
     - endDate
654 
    """
655 
    pass
656 
 
11980 amit.gupta 657 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 658 
    """
659 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 660 
 
11592 amit.gupta 661 
    Parameters:
662 
     - cartId
663 
     - sourceId
11980 amit.gupta 664 
     - dealerCoupon
11592 amit.gupta 665 
    """
666 
    pass
667 
 
11679 vikram.rag 668 
  def isPrivateDealUser(self, userId):
669 
    """
670 
    Parameters:
671 
     - userId
672 
    """
673 
    pass
11592 amit.gupta 674 
 
11890 kshitij.so 675 
  def addPrivateDealUser(self, userId):
676 
    """
677 
    Parameters:
678 
     - userId
679 
    """
680 
    pass
11679 vikram.rag 681 
 
11890 kshitij.so 682 
  def changePrivateDealUserStatus(self, userId, isActive):
683 
    """
684 
    Parameters:
685 
     - userId
686 
     - isActive
687 
    """
688 
    pass
689 
 
690 
  def getPrivateDealUser(self, userId):
691 
    """
692 
    Parameters:
693 
     - userId
694 
    """
695 
    pass
696 
 
12696 amit.gupta 697 
  def registerCounter(self, counter, userId):
698 
    """
699 
    Parameters:
700 
     - counter
701 
     - userId
702 
    """
703 
    pass
11890 kshitij.so 704 
 
12722 amit.gupta 705 
  def searchCounter(self, type1, searchString):
706 
    """
707 
    Parameters:
708 
     - type1
709 
     - searchString
710 
    """
711 
    pass
12696 amit.gupta 712 
 
18977 amit.gupta 713 
  def getCounterByUserId(self, userId):
714 
    """
715 
    Parameters:
716 
     - userId
717 
    """
718 
    pass
719 
 
12722 amit.gupta 720 
  def getAllUsersByCounter(self, counterId):
721 
    """
722 
    Parameters:
723 
     - counterId
724 
    """
725 
    pass
726 
 
15251 manish.sha 727 
  def getActiveAccessTokenForUser(self, userId, source):
728 
    """
729 
    Parameters:
730 
     - userId
731 
     - source
732 
    """
733 
    pass
12722 amit.gupta 734 
 
15251 manish.sha 735 
  def validateAccessToken(self, accessToken):
736 
    """
737 
    Parameters:
738 
     - accessToken
739 
    """
740 
    pass
741 
 
17782 amit.gupta 742 
  def addItemsToCart(self, cartId, itemQty, couponCode):
743 
    """
744 
    Parameters:
745 
     - cartId
746 
     - itemQty
747 
     - couponCode
748 
    """
749 
    pass
15251 manish.sha 750 
 
17782 amit.gupta 751 
  def validateCartNew(self, cartId, pinCode, sourceId):
752 
    """
753 
    Parameters:
754 
     - cartId
755 
     - pinCode
756 
     - sourceId
757 
    """
758 
    pass
759 
 
18644 manish.sha 760 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 761 
    """
762 
    Parameters:
763 
     - userId
764 
    """
765 
    pass
17782 amit.gupta 766 
 
18530 manish.sha 767 
  def getBillingAddressForUser(self, userId):
768 
    """
769 
    Parameters:
770 
     - userId
771 
    """
772 
    pass
773 
 
18590 manish.sha 774 
  def isCreditorAssigned(self, userId):
775 
    """
776 
    Parameters:
777 
     - userId
778 
    """
779 
    pass
18530 manish.sha 780 
 
18735 manish.sha 781 
  def isTaxInvoiceEnabledUser(self, userId):
782 
    """
783 
    Parameters:
784 
     - userId
785 
    """
786 
    pass
18590 manish.sha 787 
 
18764 kshitij.so 788 
  def getCartByValue(self, cartIds):
789 
    """
790 
    Parameters:
791 
     - cartIds
792 
    """
793 
    pass
18735 manish.sha 794 
 
18764 kshitij.so 795 
 
3376 rajveer 796 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 797 
  """
798 
  service
799 
  """
800 
  def __init__(self, iprot, oprot=None):
3376 rajveer 801 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 802 
 
559 chandransh 803 
  def createAnonymousUser(self, jsessionId):
94 ashish 804 
    """
805 
    Parameters:
559 chandransh 806 
     - jsessionId
94 ashish 807 
    """
559 chandransh 808 
    self.send_createAnonymousUser(jsessionId)
809 
    return self.recv_createAnonymousUser()
94 ashish 810 
 
559 chandransh 811 
  def send_createAnonymousUser(self, jsessionId):
812 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
813 
    args = createAnonymousUser_args()
814 
    args.jsessionId = jsessionId
94 ashish 815 
    args.write(self._oprot)
816 
    self._oprot.writeMessageEnd()
817 
    self._oprot.trans.flush()
818 
 
559 chandransh 819 
  def recv_createAnonymousUser(self, ):
94 ashish 820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
821 
    if mtype == TMessageType.EXCEPTION:
822 
      x = TApplicationException()
823 
      x.read(self._iprot)
824 
      self._iprot.readMessageEnd()
825 
      raise x
559 chandransh 826 
    result = createAnonymousUser_result()
94 ashish 827 
    result.read(self._iprot)
828 
    self._iprot.readMessageEnd()
3431 rajveer 829 
    if result.success is not None:
94 ashish 830 
      return result.success
3431 rajveer 831 
    if result.ucex is not None:
559 chandransh 832 
      raise result.ucex
833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 834 
 
559 chandransh 835 
  def getUserById(self, userId):
94 ashish 836 
    """
837 
    Parameters:
838 
     - userId
839 
    """
559 chandransh 840 
    self.send_getUserById(userId)
841 
    return self.recv_getUserById()
94 ashish 842 
 
559 chandransh 843 
  def send_getUserById(self, userId):
844 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
845 
    args = getUserById_args()
94 ashish 846 
    args.userId = userId
847 
    args.write(self._oprot)
848 
    self._oprot.writeMessageEnd()
849 
    self._oprot.trans.flush()
850 
 
559 chandransh 851 
  def recv_getUserById(self, ):
94 ashish 852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
853 
    if mtype == TMessageType.EXCEPTION:
854 
      x = TApplicationException()
855 
      x.read(self._iprot)
856 
      self._iprot.readMessageEnd()
857 
      raise x
559 chandransh 858 
    result = getUserById_result()
94 ashish 859 
    result.read(self._iprot)
860 
    self._iprot.readMessageEnd()
3431 rajveer 861 
    if result.success is not None:
94 ashish 862 
      return result.success
3431 rajveer 863 
    if result.ucex is not None:
559 chandransh 864 
      raise result.ucex
865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 866 
 
5326 rajveer 867 
  def getUserByCartId(self, cartId):
868 
    """
869 
    Parameters:
870 
     - cartId
871 
    """
872 
    self.send_getUserByCartId(cartId)
873 
    return self.recv_getUserByCartId()
874 
 
875 
  def send_getUserByCartId(self, cartId):
876 
    self._oprot.writeMessageBegin('getUserByCartId', TMessageType.CALL, self._seqid)
877 
    args = getUserByCartId_args()
878 
    args.cartId = cartId
879 
    args.write(self._oprot)
880 
    self._oprot.writeMessageEnd()
881 
    self._oprot.trans.flush()
882 
 
883 
  def recv_getUserByCartId(self, ):
884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
885 
    if mtype == TMessageType.EXCEPTION:
886 
      x = TApplicationException()
887 
      x.read(self._iprot)
888 
      self._iprot.readMessageEnd()
889 
      raise x
890 
    result = getUserByCartId_result()
891 
    result.read(self._iprot)
892 
    self._iprot.readMessageEnd()
893 
    if result.success is not None:
894 
      return result.success
895 
    if result.ucex is not None:
896 
      raise result.ucex
897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByCartId failed: unknown result");
898 
 
1491 vikas 899 
  def getUserByEmail(self, email):
900 
    """
901 
    Parameters:
902 
     - email
903 
    """
904 
    self.send_getUserByEmail(email)
905 
    return self.recv_getUserByEmail()
906 
 
907 
  def send_getUserByEmail(self, email):
908 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
909 
    args = getUserByEmail_args()
910 
    args.email = email
911 
    args.write(self._oprot)
912 
    self._oprot.writeMessageEnd()
913 
    self._oprot.trans.flush()
914 
 
915 
  def recv_getUserByEmail(self, ):
916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
917 
    if mtype == TMessageType.EXCEPTION:
918 
      x = TApplicationException()
919 
      x.read(self._iprot)
920 
      self._iprot.readMessageEnd()
921 
      raise x
922 
    result = getUserByEmail_result()
923 
    result.read(self._iprot)
924 
    self._iprot.readMessageEnd()
3431 rajveer 925 
    if result.success is not None:
1491 vikas 926 
      return result.success
3431 rajveer 927 
    if result.ucex is not None:
1491 vikas 928 
      raise result.ucex
929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
930 
 
3032 mandeep.dh 931 
  def getUserByMobileNumber(self, mobileNumber):
932 
    """
933 
    Parameters:
934 
     - mobileNumber
935 
    """
936 
    self.send_getUserByMobileNumber(mobileNumber)
937 
    return self.recv_getUserByMobileNumber()
938 
 
939 
  def send_getUserByMobileNumber(self, mobileNumber):
940 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
941 
    args = getUserByMobileNumber_args()
942 
    args.mobileNumber = mobileNumber
943 
    args.write(self._oprot)
944 
    self._oprot.writeMessageEnd()
945 
    self._oprot.trans.flush()
946 
 
947 
  def recv_getUserByMobileNumber(self, ):
948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
949 
    if mtype == TMessageType.EXCEPTION:
950 
      x = TApplicationException()
951 
      x.read(self._iprot)
952 
      self._iprot.readMessageEnd()
953 
      raise x
954 
    result = getUserByMobileNumber_result()
955 
    result.read(self._iprot)
956 
    self._iprot.readMessageEnd()
3431 rajveer 957 
    if result.success is not None:
3032 mandeep.dh 958 
      return result.success
3431 rajveer 959 
    if result.ucex is not None:
3032 mandeep.dh 960 
      raise result.ucex
961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
962 
 
559 chandransh 963 
  def createUser(self, user):
94 ashish 964 
    """
965 
    Parameters:
559 chandransh 966 
     - user
94 ashish 967 
    """
559 chandransh 968 
    self.send_createUser(user)
969 
    return self.recv_createUser()
94 ashish 970 
 
559 chandransh 971 
  def send_createUser(self, user):
972 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
973 
    args = createUser_args()
974 
    args.user = user
94 ashish 975 
    args.write(self._oprot)
976 
    self._oprot.writeMessageEnd()
977 
    self._oprot.trans.flush()
978 
 
559 chandransh 979 
  def recv_createUser(self, ):
94 ashish 980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
981 
    if mtype == TMessageType.EXCEPTION:
982 
      x = TApplicationException()
983 
      x.read(self._iprot)
984 
      self._iprot.readMessageEnd()
985 
      raise x
559 chandransh 986 
    result = createUser_result()
94 ashish 987 
    result.read(self._iprot)
988 
    self._iprot.readMessageEnd()
3431 rajveer 989 
    if result.success is not None:
94 ashish 990 
      return result.success
3431 rajveer 991 
    if result.ucex is not None:
559 chandransh 992 
      raise result.ucex
993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 994 
 
559 chandransh 995 
  def updateUser(self, user):
94 ashish 996 
    """
997 
    Parameters:
559 chandransh 998 
     - user
94 ashish 999 
    """
559 chandransh 1000 
    self.send_updateUser(user)
1001 
    return self.recv_updateUser()
94 ashish 1002 
 
559 chandransh 1003 
  def send_updateUser(self, user):
1004 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
1005 
    args = updateUser_args()
1006 
    args.user = user
94 ashish 1007 
    args.write(self._oprot)
1008 
    self._oprot.writeMessageEnd()
1009 
    self._oprot.trans.flush()
1010 
 
559 chandransh 1011 
  def recv_updateUser(self, ):
94 ashish 1012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1013 
    if mtype == TMessageType.EXCEPTION:
1014 
      x = TApplicationException()
1015 
      x.read(self._iprot)
1016 
      self._iprot.readMessageEnd()
1017 
      raise x
559 chandransh 1018 
    result = updateUser_result()
94 ashish 1019 
    result.read(self._iprot)
1020 
    self._iprot.readMessageEnd()
3431 rajveer 1021 
    if result.success is not None:
94 ashish 1022 
      return result.success
3431 rajveer 1023 
    if result.ucex is not None:
559 chandransh 1024 
      raise result.ucex
1025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 1026 
 
559 chandransh 1027 
  def authenticateUser(self, email, password):
94 ashish 1028 
    """
1029 
    Parameters:
1030 
     - email
1031 
     - password
1032 
    """
559 chandransh 1033 
    self.send_authenticateUser(email, password)
122 ashish 1034 
    return self.recv_authenticateUser()
1035 
 
559 chandransh 1036 
  def send_authenticateUser(self, email, password):
122 ashish 1037 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
1038 
    args = authenticateUser_args()
559 chandransh 1039 
    args.email = email
122 ashish 1040 
    args.password = password
1041 
    args.write(self._oprot)
1042 
    self._oprot.writeMessageEnd()
1043 
    self._oprot.trans.flush()
1044 
 
1045 
  def recv_authenticateUser(self, ):
1046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1047 
    if mtype == TMessageType.EXCEPTION:
1048 
      x = TApplicationException()
1049 
      x.read(self._iprot)
1050 
      self._iprot.readMessageEnd()
1051 
      raise x
1052 
    result = authenticateUser_result()
1053 
    result.read(self._iprot)
1054 
    self._iprot.readMessageEnd()
3431 rajveer 1055 
    if result.success is not None:
122 ashish 1056 
      return result.success
3431 rajveer 1057 
    if result.auex is not None:
559 chandransh 1058 
      raise result.auex
122 ashish 1059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
1060 
 
94 ashish 1061 
  def userExists(self, email):
1062 
    """
1063 
    Parameters:
1064 
     - email
1065 
    """
1066 
    self.send_userExists(email)
1067 
    return self.recv_userExists()
1068 
 
1069 
  def send_userExists(self, email):
1070 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
1071 
    args = userExists_args()
1072 
    args.email = email
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_userExists(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = userExists_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
3431 rajveer 1087 
    if result.success is not None:
94 ashish 1088 
      return result.success
3431 rajveer 1089 
    if result.ucx is not None:
94 ashish 1090 
      raise result.ucx
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
1092 
 
567 rajveer 1093 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 1094 
    """
1095 
    Parameters:
1096 
     - userId
1097 
     - address
513 rajveer 1098 
     - setDefault
94 ashish 1099 
    """
567 rajveer 1100 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 1101 
    return self.recv_addAddressForUser()
1102 
 
567 rajveer 1103 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 1104 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
1105 
    args = addAddressForUser_args()
559 chandransh 1106 
    args.userId = userId
94 ashish 1107 
    args.address = address
513 rajveer 1108 
    args.setDefault = setDefault
94 ashish 1109 
    args.write(self._oprot)
1110 
    self._oprot.writeMessageEnd()
1111 
    self._oprot.trans.flush()
1112 
 
1113 
  def recv_addAddressForUser(self, ):
1114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1115 
    if mtype == TMessageType.EXCEPTION:
1116 
      x = TApplicationException()
1117 
      x.read(self._iprot)
1118 
      self._iprot.readMessageEnd()
1119 
      raise x
1120 
    result = addAddressForUser_result()
1121 
    result.read(self._iprot)
1122 
    self._iprot.readMessageEnd()
3431 rajveer 1123 
    if result.success is not None:
94 ashish 1124 
      return result.success
3431 rajveer 1125 
    if result.ucx is not None:
94 ashish 1126 
      raise result.ucx
1127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
1128 
 
1129 
  def removeAddressForUser(self, userid, addressId):
1130 
    """
1131 
    Parameters:
1132 
     - userid
1133 
     - addressId
1134 
    """
1135 
    self.send_removeAddressForUser(userid, addressId)
1136 
    return self.recv_removeAddressForUser()
1137 
 
1138 
  def send_removeAddressForUser(self, userid, addressId):
1139 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
1140 
    args = removeAddressForUser_args()
1141 
    args.userid = userid
1142 
    args.addressId = addressId
1143 
    args.write(self._oprot)
1144 
    self._oprot.writeMessageEnd()
1145 
    self._oprot.trans.flush()
1146 
 
1147 
  def recv_removeAddressForUser(self, ):
1148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1149 
    if mtype == TMessageType.EXCEPTION:
1150 
      x = TApplicationException()
1151 
      x.read(self._iprot)
1152 
      self._iprot.readMessageEnd()
1153 
      raise x
1154 
    result = removeAddressForUser_result()
1155 
    result.read(self._iprot)
1156 
    self._iprot.readMessageEnd()
3431 rajveer 1157 
    if result.success is not None:
94 ashish 1158 
      return result.success
3431 rajveer 1159 
    if result.ucx is not None:
94 ashish 1160 
      raise result.ucx
1161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
1162 
 
1163 
  def setUserAsLoggedIn(self, userId, timestamp):
1164 
    """
1165 
    Parameters:
1166 
     - userId
1167 
     - timestamp
1168 
    """
1169 
    self.send_setUserAsLoggedIn(userId, timestamp)
1170 
    return self.recv_setUserAsLoggedIn()
1171 
 
1172 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1173 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1174 
    args = setUserAsLoggedIn_args()
1175 
    args.userId = userId
1176 
    args.timestamp = timestamp
1177 
    args.write(self._oprot)
1178 
    self._oprot.writeMessageEnd()
1179 
    self._oprot.trans.flush()
1180 
 
1181 
  def recv_setUserAsLoggedIn(self, ):
1182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1183 
    if mtype == TMessageType.EXCEPTION:
1184 
      x = TApplicationException()
1185 
      x.read(self._iprot)
1186 
      self._iprot.readMessageEnd()
1187 
      raise x
1188 
    result = setUserAsLoggedIn_result()
1189 
    result.read(self._iprot)
1190 
    self._iprot.readMessageEnd()
3431 rajveer 1191 
    if result.success is not None:
94 ashish 1192 
      return result.success
3431 rajveer 1193 
    if result.ucx is not None:
94 ashish 1194 
      raise result.ucx
1195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1196 
 
1197 
  def setUserAsLoggedOut(self, userid, timestamp):
1198 
    """
1199 
    Parameters:
1200 
     - userid
1201 
     - timestamp
1202 
    """
1203 
    self.send_setUserAsLoggedOut(userid, timestamp)
1204 
    return self.recv_setUserAsLoggedOut()
1205 
 
1206 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1207 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1208 
    args = setUserAsLoggedOut_args()
1209 
    args.userid = userid
1210 
    args.timestamp = timestamp
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_setUserAsLoggedOut(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = setUserAsLoggedOut_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
94 ashish 1226 
      return result.success
3431 rajveer 1227 
    if result.ucx is not None:
94 ashish 1228 
      raise result.ucx
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1230 
 
504 rajveer 1231 
  def setDefaultAddress(self, userid, addressId):
1232 
    """
1233 
    Parameters:
1234 
     - userid
1235 
     - addressId
1236 
    """
1237 
    self.send_setDefaultAddress(userid, addressId)
1238 
    return self.recv_setDefaultAddress()
1239 
 
1240 
  def send_setDefaultAddress(self, userid, addressId):
1241 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1242 
    args = setDefaultAddress_args()
1243 
    args.userid = userid
1244 
    args.addressId = addressId
1245 
    args.write(self._oprot)
1246 
    self._oprot.writeMessageEnd()
1247 
    self._oprot.trans.flush()
1248 
 
1249 
  def recv_setDefaultAddress(self, ):
1250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1251 
    if mtype == TMessageType.EXCEPTION:
1252 
      x = TApplicationException()
1253 
      x.read(self._iprot)
1254 
      self._iprot.readMessageEnd()
1255 
      raise x
1256 
    result = setDefaultAddress_result()
1257 
    result.read(self._iprot)
1258 
    self._iprot.readMessageEnd()
3431 rajveer 1259 
    if result.success is not None:
504 rajveer 1260 
      return result.success
3431 rajveer 1261 
    if result.ucx is not None:
504 rajveer 1262 
      raise result.ucx
1263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1264 
 
594 rajveer 1265 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1266 
    """
1267 
    Parameters:
1268 
     - userid
594 rajveer 1269 
     - oldPassword
1270 
     - newPassword
94 ashish 1271 
    """
594 rajveer 1272 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1273 
    return self.recv_updatePassword()
1274 
 
594 rajveer 1275 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1276 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1277 
    args = updatePassword_args()
1278 
    args.userid = userid
594 rajveer 1279 
    args.oldPassword = oldPassword
1280 
    args.newPassword = newPassword
94 ashish 1281 
    args.write(self._oprot)
1282 
    self._oprot.writeMessageEnd()
1283 
    self._oprot.trans.flush()
1284 
 
1285 
  def recv_updatePassword(self, ):
1286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1287 
    if mtype == TMessageType.EXCEPTION:
1288 
      x = TApplicationException()
1289 
      x.read(self._iprot)
1290 
      self._iprot.readMessageEnd()
1291 
      raise x
1292 
    result = updatePassword_result()
1293 
    result.read(self._iprot)
1294 
    self._iprot.readMessageEnd()
3431 rajveer 1295 
    if result.success is not None:
94 ashish 1296 
      return result.success
3431 rajveer 1297 
    if result.ucx is not None:
94 ashish 1298 
      raise result.ucx
1299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1300 
 
884 rajveer 1301 
  def forgotPassword(self, email, newPassword):
581 rajveer 1302 
    """
1303 
    Parameters:
1304 
     - email
884 rajveer 1305 
     - newPassword
581 rajveer 1306 
    """
884 rajveer 1307 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1308 
    return self.recv_forgotPassword()
1309 
 
884 rajveer 1310 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1311 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1312 
    args = forgotPassword_args()
1313 
    args.email = email
884 rajveer 1314 
    args.newPassword = newPassword
581 rajveer 1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_forgotPassword(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = forgotPassword_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
3431 rajveer 1329 
    if result.success is not None:
581 rajveer 1330 
      return result.success
3431 rajveer 1331 
    if result.ucx is not None:
581 rajveer 1332 
      raise result.ucx
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1334 
 
594 rajveer 1335 
  def getAllAddressesForUser(self, userId):
1336 
    """
1337 
    Parameters:
1338 
     - userId
1339 
    """
1340 
    self.send_getAllAddressesForUser(userId)
1341 
    return self.recv_getAllAddressesForUser()
1342 
 
1343 
  def send_getAllAddressesForUser(self, userId):
1344 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1345 
    args = getAllAddressesForUser_args()
1346 
    args.userId = userId
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_getAllAddressesForUser(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = getAllAddressesForUser_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
3431 rajveer 1361 
    if result.success is not None:
594 rajveer 1362 
      return result.success
3431 rajveer 1363 
    if result.ucx is not None:
594 rajveer 1364 
      raise result.ucx
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1366 
 
1894 vikas 1367 
  def getAddressById(self, addressId):
1368 
    """
1369 
    Parameters:
1370 
     - addressId
1371 
    """
1372 
    self.send_getAddressById(addressId)
1373 
    return self.recv_getAddressById()
1374 
 
1375 
  def send_getAddressById(self, addressId):
1376 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1377 
    args = getAddressById_args()
1378 
    args.addressId = addressId
1379 
    args.write(self._oprot)
1380 
    self._oprot.writeMessageEnd()
1381 
    self._oprot.trans.flush()
1382 
 
1383 
  def recv_getAddressById(self, ):
1384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1385 
    if mtype == TMessageType.EXCEPTION:
1386 
      x = TApplicationException()
1387 
      x.read(self._iprot)
1388 
      self._iprot.readMessageEnd()
1389 
      raise x
1390 
    result = getAddressById_result()
1391 
    result.read(self._iprot)
1392 
    self._iprot.readMessageEnd()
3431 rajveer 1393 
    if result.success is not None:
1894 vikas 1394 
      return result.success
3431 rajveer 1395 
    if result.ucx is not None:
1894 vikas 1396 
      raise result.ucx
1397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1398 
 
594 rajveer 1399 
  def getDefaultAddressId(self, userId):
1400 
    """
1401 
    Parameters:
1402 
     - userId
1403 
    """
1404 
    self.send_getDefaultAddressId(userId)
1405 
    return self.recv_getDefaultAddressId()
1406 
 
1407 
  def send_getDefaultAddressId(self, userId):
1408 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1409 
    args = getDefaultAddressId_args()
1410 
    args.userId = userId
1411 
    args.write(self._oprot)
1412 
    self._oprot.writeMessageEnd()
1413 
    self._oprot.trans.flush()
1414 
 
1415 
  def recv_getDefaultAddressId(self, ):
1416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1417 
    if mtype == TMessageType.EXCEPTION:
1418 
      x = TApplicationException()
1419 
      x.read(self._iprot)
1420 
      self._iprot.readMessageEnd()
1421 
      raise x
1422 
    result = getDefaultAddressId_result()
1423 
    result.read(self._iprot)
1424 
    self._iprot.readMessageEnd()
3431 rajveer 1425 
    if result.success is not None:
594 rajveer 1426 
      return result.success
3431 rajveer 1427 
    if result.ucx is not None:
594 rajveer 1428 
      raise result.ucx
1429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1430 
 
785 rajveer 1431 
  def getDefaultPincode(self, userId):
1432 
    """
1433 
    Parameters:
1434 
     - userId
1435 
    """
1436 
    self.send_getDefaultPincode(userId)
1437 
    return self.recv_getDefaultPincode()
1438 
 
1439 
  def send_getDefaultPincode(self, userId):
1440 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1441 
    args = getDefaultPincode_args()
1442 
    args.userId = userId
1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getDefaultPincode(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getDefaultPincode_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
3431 rajveer 1457 
    if result.success is not None:
785 rajveer 1458 
      return result.success
3431 rajveer 1459 
    if result.ucx is not None:
785 rajveer 1460 
      raise result.ucx
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1462 
 
1274 varun.gupt 1463 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1464 
    """
1465 
    Parameters:
1466 
     - userId
1467 
     - replyTo
1468 
     - communicationType
1469 
     - orderId
1470 
     - airwaybillNo
1471 
     - productName
1472 
     - subject
1473 
     - message
1474 
    """
1475 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1476 
    return self.recv_saveUserCommunication()
1477 
 
1478 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1479 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1480 
    args = saveUserCommunication_args()
1481 
    args.userId = userId
1482 
    args.replyTo = replyTo
1483 
    args.communicationType = communicationType
1484 
    args.orderId = orderId
1485 
    args.airwaybillNo = airwaybillNo
1486 
    args.productName = productName
1487 
    args.subject = subject
1488 
    args.message = message
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_saveUserCommunication(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = saveUserCommunication_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
3431 rajveer 1503 
    if result.success is not None:
1274 varun.gupt 1504 
      return result.success
3431 rajveer 1505 
    if result.ucx is not None:
1274 varun.gupt 1506 
      raise result.ucx
1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1508 
 
1590 varun.gupt 1509 
  def getUserCommunicationById(self, id):
1510 
    """
1511 
    Parameters:
1512 
     - id
1513 
    """
1514 
    self.send_getUserCommunicationById(id)
1515 
    return self.recv_getUserCommunicationById()
1516 
 
1517 
  def send_getUserCommunicationById(self, id):
1518 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1519 
    args = getUserCommunicationById_args()
1520 
    args.id = id
1521 
    args.write(self._oprot)
1522 
    self._oprot.writeMessageEnd()
1523 
    self._oprot.trans.flush()
1524 
 
1525 
  def recv_getUserCommunicationById(self, ):
1526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1527 
    if mtype == TMessageType.EXCEPTION:
1528 
      x = TApplicationException()
1529 
      x.read(self._iprot)
1530 
      self._iprot.readMessageEnd()
1531 
      raise x
1532 
    result = getUserCommunicationById_result()
1533 
    result.read(self._iprot)
1534 
    self._iprot.readMessageEnd()
3431 rajveer 1535 
    if result.success is not None:
1590 varun.gupt 1536 
      return result.success
3431 rajveer 1537 
    if result.ucx is not None:
1590 varun.gupt 1538 
      raise result.ucx
1539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1540 
 
1541 
  def getUserCommunicationByUser(self, userId):
1542 
    """
1543 
    Parameters:
1544 
     - userId
1545 
    """
1546 
    self.send_getUserCommunicationByUser(userId)
1547 
    return self.recv_getUserCommunicationByUser()
1548 
 
1549 
  def send_getUserCommunicationByUser(self, userId):
1550 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1551 
    args = getUserCommunicationByUser_args()
1552 
    args.userId = userId
1553 
    args.write(self._oprot)
1554 
    self._oprot.writeMessageEnd()
1555 
    self._oprot.trans.flush()
1556 
 
1557 
  def recv_getUserCommunicationByUser(self, ):
1558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1559 
    if mtype == TMessageType.EXCEPTION:
1560 
      x = TApplicationException()
1561 
      x.read(self._iprot)
1562 
      self._iprot.readMessageEnd()
1563 
      raise x
1564 
    result = getUserCommunicationByUser_result()
1565 
    result.read(self._iprot)
1566 
    self._iprot.readMessageEnd()
3431 rajveer 1567 
    if result.success is not None:
1590 varun.gupt 1568 
      return result.success
3431 rajveer 1569 
    if result.ucx is not None:
1590 varun.gupt 1570 
      raise result.ucx
1571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1572 
 
1573 
  def getAllUserCommunications(self, ):
1574 
    self.send_getAllUserCommunications()
1575 
    return self.recv_getAllUserCommunications()
1576 
 
1577 
  def send_getAllUserCommunications(self, ):
1578 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1579 
    args = getAllUserCommunications_args()
1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getAllUserCommunications(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getAllUserCommunications_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
3431 rajveer 1594 
    if result.success is not None:
1590 varun.gupt 1595 
      return result.success
3431 rajveer 1596 
    if result.ucx is not None:
1590 varun.gupt 1597 
      raise result.ucx
1598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1599 
 
5407 amar.kumar 1600 
  def removeUserCommunication(self, id):
1601 
    """
1602 
    Parameters:
1603 
     - id
1604 
    """
1605 
    self.send_removeUserCommunication(id)
1606 
    self.recv_removeUserCommunication()
1607 
 
1608 
  def send_removeUserCommunication(self, id):
1609 
    self._oprot.writeMessageBegin('removeUserCommunication', TMessageType.CALL, self._seqid)
1610 
    args = removeUserCommunication_args()
1611 
    args.id = id
1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_removeUserCommunication(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = removeUserCommunication_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
1626 
    if result.ucx is not None:
1627 
      raise result.ucx
1628 
    return
1629 
 
1859 vikas 1630 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1631 
    """
1632 
    Parameters:
1633 
     - name
1859 vikas 1634 
     - addedOn
1845 vikas 1635 
    """
1859 vikas 1636 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1637 
    return self.recv_createMasterAffiliate()
1638 
 
1859 vikas 1639 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1640 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1641 
    args = createMasterAffiliate_args()
1642 
    args.name = name
1859 vikas 1643 
    args.addedOn = addedOn
1845 vikas 1644 
    args.write(self._oprot)
1645 
    self._oprot.writeMessageEnd()
1646 
    self._oprot.trans.flush()
1647 
 
1648 
  def recv_createMasterAffiliate(self, ):
1649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1650 
    if mtype == TMessageType.EXCEPTION:
1651 
      x = TApplicationException()
1652 
      x.read(self._iprot)
1653 
      self._iprot.readMessageEnd()
1654 
      raise x
1655 
    result = createMasterAffiliate_result()
1656 
    result.read(self._iprot)
1657 
    self._iprot.readMessageEnd()
3431 rajveer 1658 
    if result.success is not None:
1845 vikas 1659 
      return result.success
3431 rajveer 1660 
    if result.utx is not None:
1845 vikas 1661 
      raise result.utx
1662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1663 
 
1899 vikas 1664 
  def getAllMasterAffiliates(self, ):
1665 
    self.send_getAllMasterAffiliates()
1666 
    return self.recv_getAllMasterAffiliates()
1667 
 
1668 
  def send_getAllMasterAffiliates(self, ):
1669 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1670 
    args = getAllMasterAffiliates_args()
1671 
    args.write(self._oprot)
1672 
    self._oprot.writeMessageEnd()
1673 
    self._oprot.trans.flush()
1674 
 
1675 
  def recv_getAllMasterAffiliates(self, ):
1676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1677 
    if mtype == TMessageType.EXCEPTION:
1678 
      x = TApplicationException()
1679 
      x.read(self._iprot)
1680 
      self._iprot.readMessageEnd()
1681 
      raise x
1682 
    result = getAllMasterAffiliates_result()
1683 
    result.read(self._iprot)
1684 
    self._iprot.readMessageEnd()
3431 rajveer 1685 
    if result.success is not None:
1899 vikas 1686 
      return result.success
3431 rajveer 1687 
    if result.utx is not None:
1899 vikas 1688 
      raise result.utx
1689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1690 
 
1845 vikas 1691 
  def getMasterAffiliateById(self, id):
1692 
    """
1693 
    Parameters:
1694 
     - id
1695 
    """
1696 
    self.send_getMasterAffiliateById(id)
1697 
    return self.recv_getMasterAffiliateById()
1698 
 
1699 
  def send_getMasterAffiliateById(self, id):
1700 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1701 
    args = getMasterAffiliateById_args()
1702 
    args.id = id
1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_getMasterAffiliateById(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = getMasterAffiliateById_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
3431 rajveer 1717 
    if result.success is not None:
1845 vikas 1718 
      return result.success
3431 rajveer 1719 
    if result.utx is not None:
1845 vikas 1720 
      raise result.utx
1721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1722 
 
1723 
  def getMasterAffiliateByName(self, name):
1724 
    """
1725 
    Parameters:
1726 
     - name
1727 
    """
1728 
    self.send_getMasterAffiliateByName(name)
1729 
    return self.recv_getMasterAffiliateByName()
1730 
 
1731 
  def send_getMasterAffiliateByName(self, name):
1732 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1733 
    args = getMasterAffiliateByName_args()
1734 
    args.name = name
1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
1739 
  def recv_getMasterAffiliateByName(self, ):
1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
1746 
    result = getMasterAffiliateByName_result()
1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
3431 rajveer 1749 
    if result.success is not None:
1845 vikas 1750 
      return result.success
3431 rajveer 1751 
    if result.utx is not None:
1845 vikas 1752 
      raise result.utx
1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1754 
 
1859 vikas 1755 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1756 
    """
1757 
    Parameters:
1758 
     - name
1759 
     - url
1760 
     - masterAffiliateId
1859 vikas 1761 
     - addedOn
1845 vikas 1762 
    """
1859 vikas 1763 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1764 
    return self.recv_createAffiliate()
1765 
 
1859 vikas 1766 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1767 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1768 
    args = createAffiliate_args()
1769 
    args.name = name
1770 
    args.url = url
1771 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1772 
    args.addedOn = addedOn
1845 vikas 1773 
    args.write(self._oprot)
1774 
    self._oprot.writeMessageEnd()
1775 
    self._oprot.trans.flush()
1776 
 
1777 
  def recv_createAffiliate(self, ):
1778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1779 
    if mtype == TMessageType.EXCEPTION:
1780 
      x = TApplicationException()
1781 
      x.read(self._iprot)
1782 
      self._iprot.readMessageEnd()
1783 
      raise x
1784 
    result = createAffiliate_result()
1785 
    result.read(self._iprot)
1786 
    self._iprot.readMessageEnd()
3431 rajveer 1787 
    if result.success is not None:
1845 vikas 1788 
      return result.success
3431 rajveer 1789 
    if result.utx is not None:
1845 vikas 1790 
      raise result.utx
1791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1792 
 
1793 
  def getAffiliateById(self, id):
1794 
    """
1795 
    Parameters:
1796 
     - id
1797 
    """
1798 
    self.send_getAffiliateById(id)
1799 
    return self.recv_getAffiliateById()
1800 
 
1801 
  def send_getAffiliateById(self, id):
1802 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1803 
    args = getAffiliateById_args()
1804 
    args.id = id
1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
1809 
  def recv_getAffiliateById(self, ):
1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
1816 
    result = getAffiliateById_result()
1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
3431 rajveer 1819 
    if result.success is not None:
1845 vikas 1820 
      return result.success
3431 rajveer 1821 
    if result.utx is not None:
1845 vikas 1822 
      raise result.utx
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1824 
 
1825 
  def getAffiliateByName(self, name):
1826 
    """
1827 
    Parameters:
1828 
     - name
1829 
    """
1830 
    self.send_getAffiliateByName(name)
1831 
    return self.recv_getAffiliateByName()
1832 
 
1833 
  def send_getAffiliateByName(self, name):
1834 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1835 
    args = getAffiliateByName_args()
1836 
    args.name = name
1837 
    args.write(self._oprot)
1838 
    self._oprot.writeMessageEnd()
1839 
    self._oprot.trans.flush()
1840 
 
1841 
  def recv_getAffiliateByName(self, ):
1842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1843 
    if mtype == TMessageType.EXCEPTION:
1844 
      x = TApplicationException()
1845 
      x.read(self._iprot)
1846 
      self._iprot.readMessageEnd()
1847 
      raise x
1848 
    result = getAffiliateByName_result()
1849 
    result.read(self._iprot)
1850 
    self._iprot.readMessageEnd()
3431 rajveer 1851 
    if result.success is not None:
1845 vikas 1852 
      return result.success
3431 rajveer 1853 
    if result.utx is not None:
1845 vikas 1854 
      raise result.utx
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1856 
 
1996 vikas 1857 
  def getTrackerById(self, id):
1845 vikas 1858 
    """
1859 
    Parameters:
1860 
     - id
1861 
    """
1996 vikas 1862 
    self.send_getTrackerById(id)
1845 vikas 1863 
    return self.recv_getTrackerById()
1864 
 
1996 vikas 1865 
  def send_getTrackerById(self, id):
1845 vikas 1866 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1867 
    args = getTrackerById_args()
1996 vikas 1868 
    args.id = id
1845 vikas 1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_getTrackerById(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = getTrackerById_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
3431 rajveer 1883 
    if result.success is not None:
1845 vikas 1884 
      return result.success
3431 rajveer 1885 
    if result.utx is not None:
1845 vikas 1886 
      raise result.utx
1887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1888 
 
1996 vikas 1889 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1890 
    """
1891 
    Parameters:
1996 vikas 1892 
     - id
1845 vikas 1893 
    """
1996 vikas 1894 
    self.send_getAffiliatesByMasterAffiliate(id)
1895 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1896 
 
1996 vikas 1897 
  def send_getAffiliatesByMasterAffiliate(self, id):
1898 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1899 
    args = getAffiliatesByMasterAffiliate_args()
1900 
    args.id = id
1845 vikas 1901 
    args.write(self._oprot)
1902 
    self._oprot.writeMessageEnd()
1903 
    self._oprot.trans.flush()
1904 
 
1996 vikas 1905 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 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
1996 vikas 1912 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 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
1996 vikas 1919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1920 
 
1996 vikas 1921 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1922 
    """
1923 
    Parameters:
1996 vikas 1924 
     - affiliateId
1845 vikas 1925 
     - userId
1926 
     - event
1927 
     - url
1928 
     - data
1859 vikas 1929 
     - addedOn
1845 vikas 1930 
    """
1996 vikas 1931 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1932 
    return self.recv_addTrackLog()
1933 
 
1996 vikas 1934 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1935 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1936 
    args = addTrackLog_args()
1996 vikas 1937 
    args.affiliateId = affiliateId
1845 vikas 1938 
    args.userId = userId
1939 
    args.event = event
1940 
    args.url = url
1941 
    args.data = data
1859 vikas 1942 
    args.addedOn = addedOn
1845 vikas 1943 
    args.write(self._oprot)
1944 
    self._oprot.writeMessageEnd()
1945 
    self._oprot.trans.flush()
1946 
 
1947 
  def recv_addTrackLog(self, ):
1948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1949 
    if mtype == TMessageType.EXCEPTION:
1950 
      x = TApplicationException()
1951 
      x.read(self._iprot)
1952 
      self._iprot.readMessageEnd()
1953 
      raise x
1954 
    result = addTrackLog_result()
1955 
    result.read(self._iprot)
1956 
    self._iprot.readMessageEnd()
3431 rajveer 1957 
    if result.success is not None:
1845 vikas 1958 
      return result.success
3431 rajveer 1959 
    if result.utx is not None:
1845 vikas 1960 
      raise result.utx
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1962 
 
1963 
  def getTrackLogById(self, id):
1964 
    """
1965 
    Parameters:
1966 
     - id
1967 
    """
1968 
    self.send_getTrackLogById(id)
1969 
    return self.recv_getTrackLogById()
1970 
 
1971 
  def send_getTrackLogById(self, id):
1972 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1973 
    args = getTrackLogById_args()
1974 
    args.id = id
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_getTrackLogById(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = getTrackLogById_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
3431 rajveer 1989 
    if result.success is not None:
1845 vikas 1990 
      return result.success
3431 rajveer 1991 
    if result.utx is not None:
1845 vikas 1992 
      raise result.utx
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1994 
 
3293 vikas 1995 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1996 
    """
1997 
    Parameters:
1996 vikas 1998 
     - affiliateId
3293 vikas 1999 
     - startDate
2000 
     - endDate
1845 vikas 2001 
    """
3293 vikas 2002 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 2003 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 2004 
 
3293 vikas 2005 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 2006 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
2007 
    args = getTrackLogsByAffiliate_args()
2008 
    args.affiliateId = affiliateId
3293 vikas 2009 
    args.startDate = startDate
2010 
    args.endDate = endDate
1845 vikas 2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
1996 vikas 2015 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
1996 vikas 2022 
    result = getTrackLogsByAffiliate_result()
1845 vikas 2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
3431 rajveer 2025 
    if result.success is not None:
1845 vikas 2026 
      return result.success
3431 rajveer 2027 
    if result.utx is not None:
1845 vikas 2028 
      raise result.utx
1996 vikas 2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 2030 
 
2031 
  def getTrackLogsByUser(self, userId):
2032 
    """
2033 
    Parameters:
2034 
     - userId
2035 
    """
2036 
    self.send_getTrackLogsByUser(userId)
2037 
    return self.recv_getTrackLogsByUser()
2038 
 
2039 
  def send_getTrackLogsByUser(self, userId):
2040 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
2041 
    args = getTrackLogsByUser_args()
2042 
    args.userId = userId
2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_getTrackLogsByUser(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = getTrackLogsByUser_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
3431 rajveer 2057 
    if result.success is not None:
1845 vikas 2058 
      return result.success
3431 rajveer 2059 
    if result.utx is not None:
1845 vikas 2060 
      raise result.utx
2061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
2062 
 
1996 vikas 2063 
  def getTrackLogs(self, userId, event, url):
1845 vikas 2064 
    """
2065 
    Parameters:
2066 
     - userId
2067 
     - event
2068 
     - url
2069 
    """
1996 vikas 2070 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 2071 
    return self.recv_getTrackLogs()
2072 
 
1996 vikas 2073 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 2074 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
2075 
    args = getTrackLogs_args()
2076 
    args.userId = userId
2077 
    args.event = event
2078 
    args.url = url
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_getTrackLogs(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = getTrackLogs_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
3431 rajveer 2093 
    if result.success is not None:
1845 vikas 2094 
      return result.success
3431 rajveer 2095 
    if result.utx is not None:
1845 vikas 2096 
      raise result.utx
2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
2098 
 
559 chandransh 2099 
  def getCurrentCart(self, userId):
94 ashish 2100 
    """
2101 
    Parameters:
559 chandransh 2102 
     - userId
94 ashish 2103 
    """
559 chandransh 2104 
    self.send_getCurrentCart(userId)
2105 
    return self.recv_getCurrentCart()
94 ashish 2106 
 
559 chandransh 2107 
  def send_getCurrentCart(self, userId):
2108 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
2109 
    args = getCurrentCart_args()
2110 
    args.userId = userId
94 ashish 2111 
    args.write(self._oprot)
2112 
    self._oprot.writeMessageEnd()
2113 
    self._oprot.trans.flush()
2114 
 
559 chandransh 2115 
  def recv_getCurrentCart(self, ):
94 ashish 2116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2117 
    if mtype == TMessageType.EXCEPTION:
2118 
      x = TApplicationException()
2119 
      x.read(self._iprot)
2120 
      self._iprot.readMessageEnd()
2121 
      raise x
559 chandransh 2122 
    result = getCurrentCart_result()
94 ashish 2123 
    result.read(self._iprot)
2124 
    self._iprot.readMessageEnd()
3431 rajveer 2125 
    if result.success is not None:
94 ashish 2126 
      return result.success
3431 rajveer 2127 
    if result.scx is not None:
559 chandransh 2128 
      raise result.scx
2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 2130 
 
559 chandransh 2131 
  def getCart(self, cartId):
94 ashish 2132 
    """
2133 
    Parameters:
559 chandransh 2134 
     - cartId
94 ashish 2135 
    """
559 chandransh 2136 
    self.send_getCart(cartId)
2137 
    return self.recv_getCart()
94 ashish 2138 
 
559 chandransh 2139 
  def send_getCart(self, cartId):
2140 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2141 
    args = getCart_args()
2142 
    args.cartId = cartId
94 ashish 2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
559 chandransh 2147 
  def recv_getCart(self, ):
94 ashish 2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
559 chandransh 2154 
    result = getCart_result()
94 ashish 2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
3431 rajveer 2157 
    if result.success is not None:
94 ashish 2158 
      return result.success
3431 rajveer 2159 
    if result.scx is not None:
559 chandransh 2160 
      raise result.scx
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2162 
 
559 chandransh 2163 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2164 
    """
2165 
    Parameters:
559 chandransh 2166 
     - from_time
2167 
     - to_time
2168 
     - status
94 ashish 2169 
    """
559 chandransh 2170 
    self.send_getCartsByTime(from_time, to_time, status)
2171 
    return self.recv_getCartsByTime()
94 ashish 2172 
 
559 chandransh 2173 
  def send_getCartsByTime(self, from_time, to_time, status):
2174 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2175 
    args = getCartsByTime_args()
2176 
    args.from_time = from_time
2177 
    args.to_time = to_time
2178 
    args.status = status
94 ashish 2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
559 chandransh 2183 
  def recv_getCartsByTime(self, ):
94 ashish 2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
559 chandransh 2190 
    result = getCartsByTime_result()
94 ashish 2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
3431 rajveer 2193 
    if result.success is not None:
94 ashish 2194 
      return result.success
3431 rajveer 2195 
    if result.scx is not None:
559 chandransh 2196 
      raise result.scx
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2198 
 
3557 rajveer 2199 
  def addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2200 
    """
2201 
    Parameters:
2202 
     - cartId
2203 
     - itemId
2204 
     - quantity
3557 rajveer 2205 
     - sourceId
559 chandransh 2206 
    """
3557 rajveer 2207 
    self.send_addItemToCart(cartId, itemId, quantity, sourceId)
2035 rajveer 2208 
    return self.recv_addItemToCart()
559 chandransh 2209 
 
3557 rajveer 2210 
  def send_addItemToCart(self, cartId, itemId, quantity, sourceId):
559 chandransh 2211 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2212 
    args = addItemToCart_args()
2213 
    args.cartId = cartId
2214 
    args.itemId = itemId
2215 
    args.quantity = quantity
3557 rajveer 2216 
    args.sourceId = sourceId
559 chandransh 2217 
    args.write(self._oprot)
2218 
    self._oprot.writeMessageEnd()
2219 
    self._oprot.trans.flush()
2220 
 
2221 
  def recv_addItemToCart(self, ):
2222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2223 
    if mtype == TMessageType.EXCEPTION:
2224 
      x = TApplicationException()
2225 
      x.read(self._iprot)
2226 
      self._iprot.readMessageEnd()
2227 
      raise x
2228 
    result = addItemToCart_result()
2229 
    result.read(self._iprot)
2230 
    self._iprot.readMessageEnd()
3431 rajveer 2231 
    if result.success is not None:
2035 rajveer 2232 
      return result.success
3431 rajveer 2233 
    if result.scx is not None:
559 chandransh 2234 
      raise result.scx
2035 rajveer 2235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2236 
 
2237 
  def deleteItemFromCart(self, cartId, itemId):
2238 
    """
2239 
    Parameters:
2240 
     - cartId
2241 
     - itemId
2242 
    """
2243 
    self.send_deleteItemFromCart(cartId, itemId)
2244 
    self.recv_deleteItemFromCart()
2245 
 
2246 
  def send_deleteItemFromCart(self, cartId, itemId):
2247 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2248 
    args = deleteItemFromCart_args()
2249 
    args.cartId = cartId
2250 
    args.itemId = itemId
2251 
    args.write(self._oprot)
2252 
    self._oprot.writeMessageEnd()
2253 
    self._oprot.trans.flush()
2254 
 
2255 
  def recv_deleteItemFromCart(self, ):
2256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2257 
    if mtype == TMessageType.EXCEPTION:
2258 
      x = TApplicationException()
2259 
      x.read(self._iprot)
2260 
      self._iprot.readMessageEnd()
2261 
      raise x
2262 
    result = deleteItemFromCart_result()
2263 
    result.read(self._iprot)
2264 
    self._iprot.readMessageEnd()
3431 rajveer 2265 
    if result.scx is not None:
559 chandransh 2266 
      raise result.scx
2267 
    return
2268 
 
2269 
  def addAddressToCart(self, cartId, addressId):
2270 
    """
2271 
    Parameters:
2272 
     - cartId
2273 
     - addressId
2274 
    """
2275 
    self.send_addAddressToCart(cartId, addressId)
2276 
    self.recv_addAddressToCart()
2277 
 
2278 
  def send_addAddressToCart(self, cartId, addressId):
2279 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2280 
    args = addAddressToCart_args()
2281 
    args.cartId = cartId
2282 
    args.addressId = addressId
2283 
    args.write(self._oprot)
2284 
    self._oprot.writeMessageEnd()
2285 
    self._oprot.trans.flush()
2286 
 
2287 
  def recv_addAddressToCart(self, ):
2288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2289 
    if mtype == TMessageType.EXCEPTION:
2290 
      x = TApplicationException()
2291 
      x.read(self._iprot)
2292 
      self._iprot.readMessageEnd()
2293 
      raise x
2294 
    result = addAddressToCart_result()
2295 
    result.read(self._iprot)
2296 
    self._iprot.readMessageEnd()
3431 rajveer 2297 
    if result.scx is not None:
575 chandransh 2298 
      raise result.scx
559 chandransh 2299 
    return
2300 
 
5553 rajveer 2301 
  def addStoreToCart(self, cartId, storeId):
2302 
    """
2303 
    Parameters:
2304 
     - cartId
2305 
     - storeId
2306 
    """
2307 
    self.send_addStoreToCart(cartId, storeId)
2308 
    self.recv_addStoreToCart()
2309 
 
2310 
  def send_addStoreToCart(self, cartId, storeId):
2311 
    self._oprot.writeMessageBegin('addStoreToCart', TMessageType.CALL, self._seqid)
2312 
    args = addStoreToCart_args()
2313 
    args.cartId = cartId
2314 
    args.storeId = storeId
2315 
    args.write(self._oprot)
2316 
    self._oprot.writeMessageEnd()
2317 
    self._oprot.trans.flush()
2318 
 
2319 
  def recv_addStoreToCart(self, ):
2320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2321 
    if mtype == TMessageType.EXCEPTION:
2322 
      x = TApplicationException()
2323 
      x.read(self._iprot)
2324 
      self._iprot.readMessageEnd()
2325 
      raise x
2326 
    result = addStoreToCart_result()
2327 
    result.read(self._iprot)
2328 
    self._iprot.readMessageEnd()
2329 
    if result.scx is not None:
2330 
      raise result.scx
2331 
    return
2332 
 
6922 anupam.sin 2333 
  def applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2334 
    """
2335 
    Parameters:
6922 anupam.sin 2336 
     - cart
1976 varun.gupt 2337 
     - couponCode
2338 
    """
6922 anupam.sin 2339 
    self.send_applyCouponToCart(cart, couponCode)
1976 varun.gupt 2340 
    self.recv_applyCouponToCart()
2341 
 
6922 anupam.sin 2342 
  def send_applyCouponToCart(self, cart, couponCode):
1976 varun.gupt 2343 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2344 
    args = applyCouponToCart_args()
6922 anupam.sin 2345 
    args.cart = cart
1976 varun.gupt 2346 
    args.couponCode = couponCode
2347 
    args.write(self._oprot)
2348 
    self._oprot.writeMessageEnd()
2349 
    self._oprot.trans.flush()
2350 
 
2351 
  def recv_applyCouponToCart(self, ):
2352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2353 
    if mtype == TMessageType.EXCEPTION:
2354 
      x = TApplicationException()
2355 
      x.read(self._iprot)
2356 
      self._iprot.readMessageEnd()
2357 
      raise x
2358 
    result = applyCouponToCart_result()
2359 
    result.read(self._iprot)
2360 
    self._iprot.readMessageEnd()
3431 rajveer 2361 
    if result.scx is not None:
1976 varun.gupt 2362 
      raise result.scx
2363 
    return
2364 
 
2365 
  def removeCoupon(self, cartId):
2366 
    """
2367 
    Parameters:
2368 
     - cartId
2369 
    """
2370 
    self.send_removeCoupon(cartId)
2371 
    self.recv_removeCoupon()
2372 
 
2373 
  def send_removeCoupon(self, cartId):
2374 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2375 
    args = removeCoupon_args()
2376 
    args.cartId = cartId
2377 
    args.write(self._oprot)
2378 
    self._oprot.writeMessageEnd()
2379 
    self._oprot.trans.flush()
2380 
 
2381 
  def recv_removeCoupon(self, ):
2382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2383 
    if mtype == TMessageType.EXCEPTION:
2384 
      x = TApplicationException()
2385 
      x.read(self._iprot)
2386 
      self._iprot.readMessageEnd()
2387 
      raise x
2388 
    result = removeCoupon_result()
2389 
    result.read(self._iprot)
2390 
    self._iprot.readMessageEnd()
3431 rajveer 2391 
    if result.scx is not None:
1976 varun.gupt 2392 
      raise result.scx
2393 
    return
2394 
 
3554 varun.gupt 2395 
  def deleteDiscountsFromCart(self, cartId):
2396 
    """
2397 
    Deletes all the discounts associated with the cart
2398 
 
2399 
    Parameters:
2400 
     - cartId
2401 
    """
2402 
    self.send_deleteDiscountsFromCart(cartId)
2403 
    self.recv_deleteDiscountsFromCart()
2404 
 
2405 
  def send_deleteDiscountsFromCart(self, cartId):
2406 
    self._oprot.writeMessageBegin('deleteDiscountsFromCart', TMessageType.CALL, self._seqid)
2407 
    args = deleteDiscountsFromCart_args()
2408 
    args.cartId = cartId
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_deleteDiscountsFromCart(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = deleteDiscountsFromCart_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.scx is not None:
2424 
      raise result.scx
2425 
    return
2426 
 
2427 
  def saveDiscounts(self, discounts):
2428 
    """
2429 
    Accepts a list of thrift objects of Discount type and saves them
2430 
 
2431 
    Parameters:
2432 
     - discounts
2433 
    """
2434 
    self.send_saveDiscounts(discounts)
2435 
    self.recv_saveDiscounts()
2436 
 
2437 
  def send_saveDiscounts(self, discounts):
2438 
    self._oprot.writeMessageBegin('saveDiscounts', TMessageType.CALL, self._seqid)
2439 
    args = saveDiscounts_args()
2440 
    args.discounts = discounts
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_saveDiscounts(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = saveDiscounts_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
2455 
    if result.scx is not None:
2456 
      raise result.scx
2457 
    return
2458 
 
11526 amit.gupta 2459 
  def createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
559 chandransh 2460 
    """
690 chandransh 2461 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
3431 rajveer 2462 
 
559 chandransh 2463 
    Parameters:
2464 
     - cartId
2815 vikas 2465 
     - sessionSource
2466 
     - sessionStartTime
3858 vikas 2467 
     - firstSource
2468 
     - firstSourceTime
5326 rajveer 2469 
     - userId
6389 rajveer 2470 
     - schemeId
11526 amit.gupta 2471 
     - orderSource
559 chandransh 2472 
    """
11526 amit.gupta 2473 
    self.send_createOrders(cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource)
690 chandransh 2474 
    return self.recv_createOrders()
559 chandransh 2475 
 
11526 amit.gupta 2476 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime, firstSource, firstSourceTime, userId, schemeId, orderSource):
690 chandransh 2477 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2478 
    args = createOrders_args()
559 chandransh 2479 
    args.cartId = cartId
2815 vikas 2480 
    args.sessionSource = sessionSource
2481 
    args.sessionStartTime = sessionStartTime
3858 vikas 2482 
    args.firstSource = firstSource
2483 
    args.firstSourceTime = firstSourceTime
5326 rajveer 2484 
    args.userId = userId
6389 rajveer 2485 
    args.schemeId = schemeId
11526 amit.gupta 2486 
    args.orderSource = orderSource
559 chandransh 2487 
    args.write(self._oprot)
2488 
    self._oprot.writeMessageEnd()
2489 
    self._oprot.trans.flush()
2490 
 
690 chandransh 2491 
  def recv_createOrders(self, ):
559 chandransh 2492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2493 
    if mtype == TMessageType.EXCEPTION:
2494 
      x = TApplicationException()
2495 
      x.read(self._iprot)
2496 
      self._iprot.readMessageEnd()
2497 
      raise x
690 chandransh 2498 
    result = createOrders_result()
559 chandransh 2499 
    result.read(self._iprot)
2500 
    self._iprot.readMessageEnd()
3431 rajveer 2501 
    if result.success is not None:
130 ashish 2502 
      return result.success
3431 rajveer 2503 
    if result.scx is not None:
559 chandransh 2504 
      raise result.scx
690 chandransh 2505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2506 
 
3557 rajveer 2507 
  def validateCart(self, cartId, sourceId):
130 ashish 2508 
    """
690 chandransh 2509 
    Validates that:
2510 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2511 
    2. All of the lines in the cart are active items.
690 chandransh 2512 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2513 
    If all three are true, returns empty string; else returns appropriate message.
3431 rajveer 2514 
 
130 ashish 2515 
    Parameters:
559 chandransh 2516 
     - cartId
3557 rajveer 2517 
     - sourceId
130 ashish 2518 
    """
3557 rajveer 2519 
    self.send_validateCart(cartId, sourceId)
559 chandransh 2520 
    return self.recv_validateCart()
130 ashish 2521 
 
3557 rajveer 2522 
  def send_validateCart(self, cartId, sourceId):
559 chandransh 2523 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2524 
    args = validateCart_args()
2525 
    args.cartId = cartId
3557 rajveer 2526 
    args.sourceId = sourceId
130 ashish 2527 
    args.write(self._oprot)
2528 
    self._oprot.writeMessageEnd()
2529 
    self._oprot.trans.flush()
2530 
 
559 chandransh 2531 
  def recv_validateCart(self, ):
130 ashish 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
559 chandransh 2538 
    result = validateCart_result()
130 ashish 2539 
    result.read(self._iprot)
2540 
    self._iprot.readMessageEnd()
3431 rajveer 2541 
    if result.success is not None:
130 ashish 2542 
      return result.success
3431 rajveer 2543 
    if result.scex is not None:
575 chandransh 2544 
      raise result.scex
559 chandransh 2545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2546 
 
11980 amit.gupta 2547 
  def validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2548 
    """
2549 
    Validates that:
2550 
    1. The checkout timestamp is greater than the updatedOn timestamp.
2551 
    2. All of the lines in the cart are active items.
2552 
    3. The estimate for any of the lines in cart doesn't change.
2553 
    If all three are true, returns empty string; else returns appropriate message.
2554 
 
2555 
    Parameters:
2556 
     - cartId
2557 
     - sourceId
2558 
     - dealCoupon
2559 
    """
2560 
    self.send_validateCartWithDealerCoupon(cartId, sourceId, dealCoupon)
2561 
    return self.recv_validateCartWithDealerCoupon()
2562 
 
2563 
  def send_validateCartWithDealerCoupon(self, cartId, sourceId, dealCoupon):
2564 
    self._oprot.writeMessageBegin('validateCartWithDealerCoupon', TMessageType.CALL, self._seqid)
2565 
    args = validateCartWithDealerCoupon_args()
2566 
    args.cartId = cartId
2567 
    args.sourceId = sourceId
2568 
    args.dealCoupon = dealCoupon
2569 
    args.write(self._oprot)
2570 
    self._oprot.writeMessageEnd()
2571 
    self._oprot.trans.flush()
2572 
 
2573 
  def recv_validateCartWithDealerCoupon(self, ):
2574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2575 
    if mtype == TMessageType.EXCEPTION:
2576 
      x = TApplicationException()
2577 
      x.read(self._iprot)
2578 
      self._iprot.readMessageEnd()
2579 
      raise x
2580 
    result = validateCartWithDealerCoupon_result()
2581 
    result.read(self._iprot)
2582 
    self._iprot.readMessageEnd()
2583 
    if result.success is not None:
2584 
      return result.success
2585 
    if result.scex is not None:
2586 
      raise result.scex
2587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartWithDealerCoupon failed: unknown result");
2588 
 
690 chandransh 2589 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2590 
    """
690 chandransh 2591 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
3431 rajveer 2592 
 
575 chandransh 2593 
    Parameters:
690 chandransh 2594 
     - fromCartId
2595 
     - toCartId
2596 
    """
2597 
    self.send_mergeCart(fromCartId, toCartId)
2598 
    self.recv_mergeCart()
2599 
 
2600 
  def send_mergeCart(self, fromCartId, toCartId):
2601 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2602 
    args = mergeCart_args()
2603 
    args.fromCartId = fromCartId
2604 
    args.toCartId = toCartId
2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_mergeCart(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = mergeCart_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    return
2620 
 
2621 
  def checkOut(self, cartId):
2622 
    """
2623 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
3431 rajveer 2624 
 
690 chandransh 2625 
    Parameters:
575 chandransh 2626 
     - cartId
2627 
    """
690 chandransh 2628 
    self.send_checkOut(cartId)
2629 
    return self.recv_checkOut()
575 chandransh 2630 
 
690 chandransh 2631 
  def send_checkOut(self, cartId):
2632 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2633 
    args = checkOut_args()
575 chandransh 2634 
    args.cartId = cartId
2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
690 chandransh 2639 
  def recv_checkOut(self, ):
575 chandransh 2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
690 chandransh 2646 
    result = checkOut_result()
575 chandransh 2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
3431 rajveer 2649 
    if result.success is not None:
575 chandransh 2650 
      return result.success
3431 rajveer 2651 
    if result.scex is not None:
575 chandransh 2652 
      raise result.scex
690 chandransh 2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2654 
 
690 chandransh 2655 
  def resetCart(self, cartId, items):
559 chandransh 2656 
    """
690 chandransh 2657 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2658 
    This methods removes the specified quantiry of the specified item from the cart.
3431 rajveer 2659 
 
559 chandransh 2660 
    Parameters:
690 chandransh 2661 
     - cartId
2662 
     - items
559 chandransh 2663 
    """
690 chandransh 2664 
    self.send_resetCart(cartId, items)
2665 
    return self.recv_resetCart()
130 ashish 2666 
 
690 chandransh 2667 
  def send_resetCart(self, cartId, items):
2668 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2669 
    args = resetCart_args()
2670 
    args.cartId = cartId
2671 
    args.items = items
559 chandransh 2672 
    args.write(self._oprot)
2673 
    self._oprot.writeMessageEnd()
2674 
    self._oprot.trans.flush()
2675 
 
690 chandransh 2676 
  def recv_resetCart(self, ):
559 chandransh 2677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2678 
    if mtype == TMessageType.EXCEPTION:
2679 
      x = TApplicationException()
2680 
      x.read(self._iprot)
2681 
      self._iprot.readMessageEnd()
2682 
      raise x
690 chandransh 2683 
    result = resetCart_result()
559 chandransh 2684 
    result.read(self._iprot)
2685 
    self._iprot.readMessageEnd()
3431 rajveer 2686 
    if result.success is not None:
690 chandransh 2687 
      return result.success
3431 rajveer 2688 
    if result.scex is not None:
690 chandransh 2689 
      raise result.scex
2690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2691 
 
2981 rajveer 2692 
  def getUserCount(self, userType):
559 chandransh 2693 
    """
2981 rajveer 2694 
    Returns number of registered users.
2695 
    If userType = null, then it returns count of all users, including anonymous
2696 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2697 
    If userType = UserType.USER, then it returns count of non-anonymous users only
3431 rajveer 2698 
 
559 chandransh 2699 
    Parameters:
2981 rajveer 2700 
     - userType
559 chandransh 2701 
    """
2981 rajveer 2702 
    self.send_getUserCount(userType)
2703 
    return self.recv_getUserCount()
559 chandransh 2704 
 
2981 rajveer 2705 
  def send_getUserCount(self, userType):
2706 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2707 
    args = getUserCount_args()
2708 
    args.userType = userType
559 chandransh 2709 
    args.write(self._oprot)
2710 
    self._oprot.writeMessageEnd()
2711 
    self._oprot.trans.flush()
2712 
 
2981 rajveer 2713 
  def recv_getUserCount(self, ):
559 chandransh 2714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2715 
    if mtype == TMessageType.EXCEPTION:
2716 
      x = TApplicationException()
2717 
      x.read(self._iprot)
2718 
      self._iprot.readMessageEnd()
2719 
      raise x
2981 rajveer 2720 
    result = getUserCount_result()
559 chandransh 2721 
    result.read(self._iprot)
2722 
    self._iprot.readMessageEnd()
3431 rajveer 2723 
    if result.success is not None:
559 chandransh 2724 
      return result.success
2981 rajveer 2725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2726 
 
2981 rajveer 2727 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2728 
    """
2981 rajveer 2729 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2730 
    If any of startDate or endDate is -1, then that filter is ignored.
2731 
    If userType is null, then returns all the users, irrespective of anonymous flag
3431 rajveer 2732 
 
2733 
 
559 chandransh 2734 
    Parameters:
2981 rajveer 2735 
     - userType
2736 
     - startDate
2737 
     - endDate
559 chandransh 2738 
    """
2981 rajveer 2739 
    self.send_getAllUsers(userType, startDate, endDate)
2740 
    return self.recv_getAllUsers()
559 chandransh 2741 
 
2981 rajveer 2742 
  def send_getAllUsers(self, userType, startDate, endDate):
2743 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2744 
    args = getAllUsers_args()
2745 
    args.userType = userType
2746 
    args.startDate = startDate
2747 
    args.endDate = endDate
559 chandransh 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
2981 rajveer 2752 
  def recv_getAllUsers(self, ):
559 chandransh 2753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2754 
    if mtype == TMessageType.EXCEPTION:
2755 
      x = TApplicationException()
2756 
      x.read(self._iprot)
2757 
      self._iprot.readMessageEnd()
2758 
      raise x
2981 rajveer 2759 
    result = getAllUsers_result()
559 chandransh 2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
3431 rajveer 2762 
    if result.success is not None:
559 chandransh 2763 
      return result.success
2981 rajveer 2764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2765 
 
2981 rajveer 2766 
  def getMyResearchItems(self, userId):
559 chandransh 2767 
    """
2981 rajveer 2768 
    Returns list of item ids in myresearch for the user
3431 rajveer 2769 
 
559 chandransh 2770 
    Parameters:
772 rajveer 2771 
     - userId
559 chandransh 2772 
    """
2981 rajveer 2773 
    self.send_getMyResearchItems(userId)
2774 
    return self.recv_getMyResearchItems()
559 chandransh 2775 
 
2981 rajveer 2776 
  def send_getMyResearchItems(self, userId):
2777 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2778 
    args = getMyResearchItems_args()
772 rajveer 2779 
    args.userId = userId
559 chandransh 2780 
    args.write(self._oprot)
2781 
    self._oprot.writeMessageEnd()
2782 
    self._oprot.trans.flush()
2783 
 
2981 rajveer 2784 
  def recv_getMyResearchItems(self, ):
559 chandransh 2785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2786 
    if mtype == TMessageType.EXCEPTION:
2787 
      x = TApplicationException()
2788 
      x.read(self._iprot)
2789 
      self._iprot.readMessageEnd()
2790 
      raise x
2981 rajveer 2791 
    result = getMyResearchItems_result()
559 chandransh 2792 
    result.read(self._iprot)
2793 
    self._iprot.readMessageEnd()
3431 rajveer 2794 
    if result.success is not None:
559 chandransh 2795 
      return result.success
3431 rajveer 2796 
    if result.scx is not None:
559 chandransh 2797 
      raise result.scx
2981 rajveer 2798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2799 
 
2981 rajveer 2800 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2801 
    """
2981 rajveer 2802 
    add item to my research for a user
3431 rajveer 2803 
 
559 chandransh 2804 
    Parameters:
2981 rajveer 2805 
     - userId
2806 
     - itemId
559 chandransh 2807 
    """
2981 rajveer 2808 
    self.send_updateMyResearch(userId, itemId)
2809 
    return self.recv_updateMyResearch()
559 chandransh 2810 
 
2981 rajveer 2811 
  def send_updateMyResearch(self, userId, itemId):
2812 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2813 
    args = updateMyResearch_args()
2814 
    args.userId = userId
2815 
    args.itemId = itemId
559 chandransh 2816 
    args.write(self._oprot)
2817 
    self._oprot.writeMessageEnd()
2818 
    self._oprot.trans.flush()
2819 
 
2981 rajveer 2820 
  def recv_updateMyResearch(self, ):
559 chandransh 2821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2822 
    if mtype == TMessageType.EXCEPTION:
2823 
      x = TApplicationException()
2824 
      x.read(self._iprot)
2825 
      self._iprot.readMessageEnd()
2826 
      raise x
2981 rajveer 2827 
    result = updateMyResearch_result()
559 chandransh 2828 
    result.read(self._iprot)
2829 
    self._iprot.readMessageEnd()
3431 rajveer 2830 
    if result.success is not None:
2981 rajveer 2831 
      return result.success
3431 rajveer 2832 
    if result.scx is not None:
2981 rajveer 2833 
      raise result.scx
2834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2835 
 
2981 rajveer 2836 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2837 
    """
2981 rajveer 2838 
    delete item from my research for a user
3431 rajveer 2839 
 
1596 ankur.sing 2840 
    Parameters:
2981 rajveer 2841 
     - userId
2842 
     - itemId
1596 ankur.sing 2843 
    """
2981 rajveer 2844 
    self.send_deleteItemFromMyResearch(userId, itemId)
2845 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2846 
 
2981 rajveer 2847 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2848 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2849 
    args = deleteItemFromMyResearch_args()
2850 
    args.userId = userId
2851 
    args.itemId = itemId
1596 ankur.sing 2852 
    args.write(self._oprot)
2853 
    self._oprot.writeMessageEnd()
2854 
    self._oprot.trans.flush()
2855 
 
2981 rajveer 2856 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2858 
    if mtype == TMessageType.EXCEPTION:
2859 
      x = TApplicationException()
2860 
      x.read(self._iprot)
2861 
      self._iprot.readMessageEnd()
2862 
      raise x
2981 rajveer 2863 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2864 
    result.read(self._iprot)
2865 
    self._iprot.readMessageEnd()
3431 rajveer 2866 
    if result.scx is not None:
2981 rajveer 2867 
      raise result.scx
2868 
    return
1596 ankur.sing 2869 
 
2981 rajveer 2870 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2871 
    """
2981 rajveer 2872 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
3431 rajveer 2873 
 
1673 ankur.sing 2874 
    Parameters:
2981 rajveer 2875 
     - userId
1673 ankur.sing 2876 
    """
2981 rajveer 2877 
    self.send_getBrowseHistoryItems(userId)
2878 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2879 
 
2981 rajveer 2880 
  def send_getBrowseHistoryItems(self, userId):
2881 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2882 
    args = getBrowseHistoryItems_args()
2883 
    args.userId = userId
1673 ankur.sing 2884 
    args.write(self._oprot)
2885 
    self._oprot.writeMessageEnd()
2886 
    self._oprot.trans.flush()
2887 
 
2981 rajveer 2888 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2890 
    if mtype == TMessageType.EXCEPTION:
2891 
      x = TApplicationException()
2892 
      x.read(self._iprot)
2893 
      self._iprot.readMessageEnd()
2894 
      raise x
2981 rajveer 2895 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2896 
    result.read(self._iprot)
2897 
    self._iprot.readMessageEnd()
3431 rajveer 2898 
    if result.success is not None:
1673 ankur.sing 2899 
      return result.success
3431 rajveer 2900 
    if result.scx is not None:
2981 rajveer 2901 
      raise result.scx
2902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2903 
 
2981 rajveer 2904 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2905 
    """
2981 rajveer 2906 
    add item to browse history for a user
3431 rajveer 2907 
 
2642 varun.gupt 2908 
    Parameters:
2981 rajveer 2909 
     - userId
2910 
     - itemId
2642 varun.gupt 2911 
    """
2981 rajveer 2912 
    self.send_updateBrowseHistory(userId, itemId)
2913 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2914 
 
2981 rajveer 2915 
  def send_updateBrowseHistory(self, userId, itemId):
2916 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2917 
    args = updateBrowseHistory_args()
2918 
    args.userId = userId
2919 
    args.itemId = itemId
2642 varun.gupt 2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2981 rajveer 2924 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2981 rajveer 2931 
    result = updateBrowseHistory_result()
2642 varun.gupt 2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    return
2935 
 
3385 varun.gupt 2936 
  def getCartsWithCouponCount(self, couponCode):
2937 
    """
2938 
    Returns count of Carts with given coupon applied
3431 rajveer 2939 
 
3385 varun.gupt 2940 
    Parameters:
2941 
     - couponCode
2942 
    """
2943 
    self.send_getCartsWithCouponCount(couponCode)
2944 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2945 
 
3385 varun.gupt 2946 
  def send_getCartsWithCouponCount(self, couponCode):
2947 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2948 
    args = getCartsWithCouponCount_args()
2949 
    args.couponCode = couponCode
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_getCartsWithCouponCount(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = getCartsWithCouponCount_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
3431 rajveer 2964 
    if result.success is not None:
3385 varun.gupt 2965 
      return result.success
2966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2967 
 
3499 mandeep.dh 2968 
  def increaseTrustLevel(self, userId, trustLevelDelta):
2969 
    """
2970 
    Updates COD trust level of a user
3385 varun.gupt 2971 
 
3499 mandeep.dh 2972 
    Parameters:
2973 
     - userId
2974 
     - trustLevelDelta
2975 
    """
2976 
    self.send_increaseTrustLevel(userId, trustLevelDelta)
2977 
 
2978 
  def send_increaseTrustLevel(self, userId, trustLevelDelta):
2979 
    self._oprot.writeMessageBegin('increaseTrustLevel', TMessageType.CALL, self._seqid)
2980 
    args = increaseTrustLevel_args()
2981 
    args.userId = userId
2982 
    args.trustLevelDelta = trustLevelDelta
2983 
    args.write(self._oprot)
2984 
    self._oprot.writeMessageEnd()
2985 
    self._oprot.trans.flush()
5407 amar.kumar 2986 
  def getTrustLevel(self, userId):
2987 
    """
2988 
    Get trust level of a user
2989 
 
2990 
    Parameters:
2991 
     - userId
2992 
    """
2993 
    self.send_getTrustLevel(userId)
2994 
    return self.recv_getTrustLevel()
2995 
 
2996 
  def send_getTrustLevel(self, userId):
2997 
    self._oprot.writeMessageBegin('getTrustLevel', TMessageType.CALL, self._seqid)
2998 
    args = getTrustLevel_args()
2999 
    args.userId = userId
3000 
    args.write(self._oprot)
3001 
    self._oprot.writeMessageEnd()
3002 
    self._oprot.trans.flush()
3003 
 
3004 
  def recv_getTrustLevel(self, ):
3005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3006 
    if mtype == TMessageType.EXCEPTION:
3007 
      x = TApplicationException()
3008 
      x.read(self._iprot)
3009 
      self._iprot.readMessageEnd()
3010 
      raise x
3011 
    result = getTrustLevel_result()
3012 
    result.read(self._iprot)
3013 
    self._iprot.readMessageEnd()
3014 
    if result.success is not None:
3015 
      return result.success
3016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrustLevel failed: unknown result");
3017 
 
4668 varun.gupt 3018 
  def showCODOption(self, cartId, sourceId, pincode):
3019 
    """
3020 
    Returns true/false depending on wether COD is allowed for a cart or not
3499 mandeep.dh 3021 
 
4668 varun.gupt 3022 
    Parameters:
3023 
     - cartId
3024 
     - sourceId
3025 
     - pincode
3026 
    """
3027 
    self.send_showCODOption(cartId, sourceId, pincode)
3028 
    return self.recv_showCODOption()
3029 
 
3030 
  def send_showCODOption(self, cartId, sourceId, pincode):
3031 
    self._oprot.writeMessageBegin('showCODOption', TMessageType.CALL, self._seqid)
3032 
    args = showCODOption_args()
3033 
    args.cartId = cartId
3034 
    args.sourceId = sourceId
3035 
    args.pincode = pincode
3036 
    args.write(self._oprot)
3037 
    self._oprot.writeMessageEnd()
3038 
    self._oprot.trans.flush()
3039 
 
3040 
  def recv_showCODOption(self, ):
3041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3042 
    if mtype == TMessageType.EXCEPTION:
3043 
      x = TApplicationException()
3044 
      x.read(self._iprot)
3045 
      self._iprot.readMessageEnd()
3046 
      raise x
3047 
    result = showCODOption_result()
3048 
    result.read(self._iprot)
3049 
    self._iprot.readMessageEnd()
3050 
    if result.success is not None:
3051 
      return result.success
3052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "showCODOption failed: unknown result");
3053 
 
5623 anupam.sin 3054 
  def getUserEmails(self, startDate, endDate):
3055 
    """
3056 
    Get email addresses for users activated within a given date range
4668 varun.gupt 3057 
 
5623 anupam.sin 3058 
    Parameters:
3059 
     - startDate
3060 
     - endDate
3061 
    """
3062 
    self.send_getUserEmails(startDate, endDate)
3063 
    return self.recv_getUserEmails()
3064 
 
3065 
  def send_getUserEmails(self, startDate, endDate):
3066 
    self._oprot.writeMessageBegin('getUserEmails', TMessageType.CALL, self._seqid)
3067 
    args = getUserEmails_args()
3068 
    args.startDate = startDate
3069 
    args.endDate = endDate
3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_getUserEmails(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = getUserEmails_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
3084 
    if result.success is not None:
3085 
      return result.success
3086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserEmails failed: unknown result");
3087 
 
9299 kshitij.so 3088 
  def insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3089 
    """
3090 
    Mark a cart lineitem as insured. Returns true/false.
3091 
 
3092 
    Parameters:
3093 
     - itemId
3094 
     - cartId
3095 
     - toInsure
9299 kshitij.so 3096 
     - insurerType
6903 anupam.sin 3097 
    """
9299 kshitij.so 3098 
    self.send_insureItem(itemId, cartId, toInsure, insurerType)
6903 anupam.sin 3099 
    return self.recv_insureItem()
3100 
 
9299 kshitij.so 3101 
  def send_insureItem(self, itemId, cartId, toInsure, insurerType):
6903 anupam.sin 3102 
    self._oprot.writeMessageBegin('insureItem', TMessageType.CALL, self._seqid)
3103 
    args = insureItem_args()
3104 
    args.itemId = itemId
3105 
    args.cartId = cartId
3106 
    args.toInsure = toInsure
9299 kshitij.so 3107 
    args.insurerType = insurerType
6903 anupam.sin 3108 
    args.write(self._oprot)
3109 
    self._oprot.writeMessageEnd()
3110 
    self._oprot.trans.flush()
3111 
 
3112 
  def recv_insureItem(self, ):
3113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3114 
    if mtype == TMessageType.EXCEPTION:
3115 
      x = TApplicationException()
3116 
      x.read(self._iprot)
3117 
      self._iprot.readMessageEnd()
3118 
      raise x
3119 
    result = insureItem_result()
3120 
    result.read(self._iprot)
3121 
    self._iprot.readMessageEnd()
3122 
    if result.success is not None:
3123 
      return result.success
3124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insureItem failed: unknown result");
3125 
 
3126 
  def cancelInsurance(self, cartId):
3127 
    """
3128 
    Cancel insurance for all items in the cart
3129 
 
3130 
    Parameters:
3131 
     - cartId
3132 
    """
3133 
    self.send_cancelInsurance(cartId)
3134 
    return self.recv_cancelInsurance()
3135 
 
3136 
  def send_cancelInsurance(self, cartId):
3137 
    self._oprot.writeMessageBegin('cancelInsurance', TMessageType.CALL, self._seqid)
3138 
    args = cancelInsurance_args()
3139 
    args.cartId = cartId
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_cancelInsurance(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = cancelInsurance_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3154 
    if result.success is not None:
3155 
      return result.success
3156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "cancelInsurance failed: unknown result");
3157 
 
3158 
  def storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3159 
    """
3160 
    Stores insurance specific details like date of birth and guardianName
3161 
 
3162 
    Parameters:
3163 
     - addressId
3164 
     - dob
3165 
     - guardianName
3166 
    """
3167 
    self.send_storeInsuranceSpecificDetails(addressId, dob, guardianName)
3168 
    return self.recv_storeInsuranceSpecificDetails()
3169 
 
3170 
  def send_storeInsuranceSpecificDetails(self, addressId, dob, guardianName):
3171 
    self._oprot.writeMessageBegin('storeInsuranceSpecificDetails', TMessageType.CALL, self._seqid)
3172 
    args = storeInsuranceSpecificDetails_args()
3173 
    args.addressId = addressId
3174 
    args.dob = dob
3175 
    args.guardianName = guardianName
3176 
    args.write(self._oprot)
3177 
    self._oprot.writeMessageEnd()
3178 
    self._oprot.trans.flush()
3179 
 
3180 
  def recv_storeInsuranceSpecificDetails(self, ):
3181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3182 
    if mtype == TMessageType.EXCEPTION:
3183 
      x = TApplicationException()
3184 
      x.read(self._iprot)
3185 
      self._iprot.readMessageEnd()
3186 
      raise x
3187 
    result = storeInsuranceSpecificDetails_result()
3188 
    result.read(self._iprot)
3189 
    self._iprot.readMessageEnd()
3190 
    if result.success is not None:
3191 
      return result.success
3192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "storeInsuranceSpecificDetails failed: unknown result");
3193 
 
3194 
  def isInsuranceDetailPresent(self, addressId):
3195 
    """
3196 
    Return true or false based on whether the user has stored any insurance info corresponding to the given addressId
3197 
 
3198 
    Parameters:
3199 
     - addressId
3200 
    """
3201 
    self.send_isInsuranceDetailPresent(addressId)
3202 
    return self.recv_isInsuranceDetailPresent()
3203 
 
3204 
  def send_isInsuranceDetailPresent(self, addressId):
3205 
    self._oprot.writeMessageBegin('isInsuranceDetailPresent', TMessageType.CALL, self._seqid)
3206 
    args = isInsuranceDetailPresent_args()
3207 
    args.addressId = addressId
3208 
    args.write(self._oprot)
3209 
    self._oprot.writeMessageEnd()
3210 
    self._oprot.trans.flush()
3211 
 
3212 
  def recv_isInsuranceDetailPresent(self, ):
3213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3214 
    if mtype == TMessageType.EXCEPTION:
3215 
      x = TApplicationException()
3216 
      x.read(self._iprot)
3217 
      self._iprot.readMessageEnd()
3218 
      raise x
3219 
    result = isInsuranceDetailPresent_result()
3220 
    result.read(self._iprot)
3221 
    self._iprot.readMessageEnd()
3222 
    if result.success is not None:
3223 
      return result.success
3224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isInsuranceDetailPresent failed: unknown result");
3225 
 
9791 rajveer 3226 
  def getProductsAddedToCart(self, startDate, endDate):
6821 amar.kumar 3227 
    """
9791 rajveer 3228 
    Returns list of item ids which added to cart from startDate to endDate
5623 anupam.sin 3229 
 
6821 amar.kumar 3230 
    Parameters:
3231 
     - startDate
3232 
     - endDate
3233 
    """
9791 rajveer 3234 
    self.send_getProductsAddedToCart(startDate, endDate)
3235 
    return self.recv_getProductsAddedToCart()
6821 amar.kumar 3236 
 
9791 rajveer 3237 
  def send_getProductsAddedToCart(self, startDate, endDate):
3238 
    self._oprot.writeMessageBegin('getProductsAddedToCart', TMessageType.CALL, self._seqid)
3239 
    args = getProductsAddedToCart_args()
6821 amar.kumar 3240 
    args.startDate = startDate
3241 
    args.endDate = endDate
3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
9791 rajveer 3246 
  def recv_getProductsAddedToCart(self, ):
6821 amar.kumar 3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
9791 rajveer 3253 
    result = getProductsAddedToCart_result()
6821 amar.kumar 3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
3256 
    if result.success is not None:
3257 
      return result.success
9791 rajveer 3258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductsAddedToCart failed: unknown result");
6821 amar.kumar 3259 
 
11980 amit.gupta 3260 
  def validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3261 
    """
3262 
    This method is speciically used to avoid overloadaed calls to userClient
6821 amar.kumar 3263 
 
11592 amit.gupta 3264 
    Parameters:
3265 
     - cartId
3266 
     - sourceId
11980 amit.gupta 3267 
     - dealerCoupon
11592 amit.gupta 3268 
    """
11980 amit.gupta 3269 
    self.send_validateCartPlus(cartId, sourceId, dealerCoupon)
11592 amit.gupta 3270 
    return self.recv_validateCartPlus()
3271 
 
11980 amit.gupta 3272 
  def send_validateCartPlus(self, cartId, sourceId, dealerCoupon):
11592 amit.gupta 3273 
    self._oprot.writeMessageBegin('validateCartPlus', TMessageType.CALL, self._seqid)
3274 
    args = validateCartPlus_args()
3275 
    args.cartId = cartId
3276 
    args.sourceId = sourceId
11980 amit.gupta 3277 
    args.dealerCoupon = dealerCoupon
11592 amit.gupta 3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_validateCartPlus(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = validateCartPlus_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.success is not None:
3293 
      return result.success
3294 
    if result.scex is not None:
3295 
      raise result.scex
3296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartPlus failed: unknown result");
3297 
 
11679 vikram.rag 3298 
  def isPrivateDealUser(self, userId):
3299 
    """
3300 
    Parameters:
3301 
     - userId
3302 
    """
3303 
    self.send_isPrivateDealUser(userId)
3304 
    return self.recv_isPrivateDealUser()
11592 amit.gupta 3305 
 
11679 vikram.rag 3306 
  def send_isPrivateDealUser(self, userId):
3307 
    self._oprot.writeMessageBegin('isPrivateDealUser', TMessageType.CALL, self._seqid)
3308 
    args = isPrivateDealUser_args()
3309 
    args.userId = userId
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_isPrivateDealUser(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = isPrivateDealUser_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3324 
    if result.success is not None:
3325 
      return result.success
3326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isPrivateDealUser failed: unknown result");
3327 
 
11890 kshitij.so 3328 
  def addPrivateDealUser(self, userId):
3329 
    """
3330 
    Parameters:
3331 
     - userId
3332 
    """
3333 
    self.send_addPrivateDealUser(userId)
3334 
    return self.recv_addPrivateDealUser()
11679 vikram.rag 3335 
 
11890 kshitij.so 3336 
  def send_addPrivateDealUser(self, userId):
3337 
    self._oprot.writeMessageBegin('addPrivateDealUser', TMessageType.CALL, self._seqid)
3338 
    args = addPrivateDealUser_args()
3339 
    args.userId = userId
3340 
    args.write(self._oprot)
3341 
    self._oprot.writeMessageEnd()
3342 
    self._oprot.trans.flush()
3343 
 
3344 
  def recv_addPrivateDealUser(self, ):
3345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3346 
    if mtype == TMessageType.EXCEPTION:
3347 
      x = TApplicationException()
3348 
      x.read(self._iprot)
3349 
      self._iprot.readMessageEnd()
3350 
      raise x
3351 
    result = addPrivateDealUser_result()
3352 
    result.read(self._iprot)
3353 
    self._iprot.readMessageEnd()
3354 
    if result.success is not None:
3355 
      return result.success
3356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addPrivateDealUser failed: unknown result");
3357 
 
3358 
  def changePrivateDealUserStatus(self, userId, isActive):
3359 
    """
3360 
    Parameters:
3361 
     - userId
3362 
     - isActive
3363 
    """
3364 
    self.send_changePrivateDealUserStatus(userId, isActive)
3365 
    return self.recv_changePrivateDealUserStatus()
3366 
 
3367 
  def send_changePrivateDealUserStatus(self, userId, isActive):
3368 
    self._oprot.writeMessageBegin('changePrivateDealUserStatus', TMessageType.CALL, self._seqid)
3369 
    args = changePrivateDealUserStatus_args()
3370 
    args.userId = userId
3371 
    args.isActive = isActive
3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
3376 
  def recv_changePrivateDealUserStatus(self, ):
3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
3383 
    result = changePrivateDealUserStatus_result()
3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3386 
    if result.success is not None:
3387 
      return result.success
3388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changePrivateDealUserStatus failed: unknown result");
3389 
 
3390 
  def getPrivateDealUser(self, userId):
3391 
    """
3392 
    Parameters:
3393 
     - userId
3394 
    """
3395 
    self.send_getPrivateDealUser(userId)
3396 
    return self.recv_getPrivateDealUser()
3397 
 
3398 
  def send_getPrivateDealUser(self, userId):
3399 
    self._oprot.writeMessageBegin('getPrivateDealUser', TMessageType.CALL, self._seqid)
3400 
    args = getPrivateDealUser_args()
3401 
    args.userId = userId
3402 
    args.write(self._oprot)
3403 
    self._oprot.writeMessageEnd()
3404 
    self._oprot.trans.flush()
3405 
 
3406 
  def recv_getPrivateDealUser(self, ):
3407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3408 
    if mtype == TMessageType.EXCEPTION:
3409 
      x = TApplicationException()
3410 
      x.read(self._iprot)
3411 
      self._iprot.readMessageEnd()
3412 
      raise x
3413 
    result = getPrivateDealUser_result()
3414 
    result.read(self._iprot)
3415 
    self._iprot.readMessageEnd()
3416 
    if result.success is not None:
3417 
      return result.success
3418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealUser failed: unknown result");
3419 
 
12696 amit.gupta 3420 
  def registerCounter(self, counter, userId):
3421 
    """
3422 
    Parameters:
3423 
     - counter
3424 
     - userId
3425 
    """
3426 
    self.send_registerCounter(counter, userId)
3427 
    return self.recv_registerCounter()
11890 kshitij.so 3428 
 
12696 amit.gupta 3429 
  def send_registerCounter(self, counter, userId):
3430 
    self._oprot.writeMessageBegin('registerCounter', TMessageType.CALL, self._seqid)
3431 
    args = registerCounter_args()
3432 
    args.counter = counter
3433 
    args.userId = userId
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_registerCounter(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = registerCounter_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "registerCounter failed: unknown result");
3451 
 
12722 amit.gupta 3452 
  def searchCounter(self, type1, searchString):
3453 
    """
3454 
    Parameters:
3455 
     - type1
3456 
     - searchString
3457 
    """
3458 
    self.send_searchCounter(type1, searchString)
3459 
    return self.recv_searchCounter()
12696 amit.gupta 3460 
 
12722 amit.gupta 3461 
  def send_searchCounter(self, type1, searchString):
3462 
    self._oprot.writeMessageBegin('searchCounter', TMessageType.CALL, self._seqid)
3463 
    args = searchCounter_args()
3464 
    args.type1 = type1
3465 
    args.searchString = searchString
3466 
    args.write(self._oprot)
3467 
    self._oprot.writeMessageEnd()
3468 
    self._oprot.trans.flush()
3469 
 
3470 
  def recv_searchCounter(self, ):
3471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3472 
    if mtype == TMessageType.EXCEPTION:
3473 
      x = TApplicationException()
3474 
      x.read(self._iprot)
3475 
      self._iprot.readMessageEnd()
3476 
      raise x
3477 
    result = searchCounter_result()
3478 
    result.read(self._iprot)
3479 
    self._iprot.readMessageEnd()
3480 
    if result.success is not None:
3481 
      return result.success
3482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchCounter failed: unknown result");
3483 
 
18977 amit.gupta 3484 
  def getCounterByUserId(self, userId):
3485 
    """
3486 
    Parameters:
3487 
     - userId
3488 
    """
3489 
    self.send_getCounterByUserId(userId)
3490 
    return self.recv_getCounterByUserId()
3491 
 
3492 
  def send_getCounterByUserId(self, userId):
3493 
    self._oprot.writeMessageBegin('getCounterByUserId', TMessageType.CALL, self._seqid)
3494 
    args = getCounterByUserId_args()
3495 
    args.userId = userId
3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_getCounterByUserId(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = getCounterByUserId_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3510 
    if result.success is not None:
3511 
      return result.success
3512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCounterByUserId failed: unknown result");
3513 
 
12722 amit.gupta 3514 
  def getAllUsersByCounter(self, counterId):
3515 
    """
3516 
    Parameters:
3517 
     - counterId
3518 
    """
3519 
    self.send_getAllUsersByCounter(counterId)
3520 
    return self.recv_getAllUsersByCounter()
3521 
 
3522 
  def send_getAllUsersByCounter(self, counterId):
3523 
    self._oprot.writeMessageBegin('getAllUsersByCounter', TMessageType.CALL, self._seqid)
3524 
    args = getAllUsersByCounter_args()
3525 
    args.counterId = counterId
3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
3530 
  def recv_getAllUsersByCounter(self, ):
3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
3537 
    result = getAllUsersByCounter_result()
3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3540 
    if result.success is not None:
3541 
      return result.success
3542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsersByCounter failed: unknown result");
3543 
 
15251 manish.sha 3544 
  def getActiveAccessTokenForUser(self, userId, source):
3545 
    """
3546 
    Parameters:
3547 
     - userId
3548 
     - source
3549 
    """
3550 
    self.send_getActiveAccessTokenForUser(userId, source)
3551 
    return self.recv_getActiveAccessTokenForUser()
12722 amit.gupta 3552 
 
15251 manish.sha 3553 
  def send_getActiveAccessTokenForUser(self, userId, source):
3554 
    self._oprot.writeMessageBegin('getActiveAccessTokenForUser', TMessageType.CALL, self._seqid)
3555 
    args = getActiveAccessTokenForUser_args()
3556 
    args.userId = userId
3557 
    args.source = source
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_getActiveAccessTokenForUser(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = getActiveAccessTokenForUser_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
3572 
    if result.success is not None:
3573 
      return result.success
3574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveAccessTokenForUser failed: unknown result");
3575 
 
3576 
  def validateAccessToken(self, accessToken):
3577 
    """
3578 
    Parameters:
3579 
     - accessToken
3580 
    """
3581 
    self.send_validateAccessToken(accessToken)
3582 
    return self.recv_validateAccessToken()
3583 
 
3584 
  def send_validateAccessToken(self, accessToken):
3585 
    self._oprot.writeMessageBegin('validateAccessToken', TMessageType.CALL, self._seqid)
3586 
    args = validateAccessToken_args()
3587 
    args.accessToken = accessToken
3588 
    args.write(self._oprot)
3589 
    self._oprot.writeMessageEnd()
3590 
    self._oprot.trans.flush()
3591 
 
3592 
  def recv_validateAccessToken(self, ):
3593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3594 
    if mtype == TMessageType.EXCEPTION:
3595 
      x = TApplicationException()
3596 
      x.read(self._iprot)
3597 
      self._iprot.readMessageEnd()
3598 
      raise x
3599 
    result = validateAccessToken_result()
3600 
    result.read(self._iprot)
3601 
    self._iprot.readMessageEnd()
3602 
    if result.success is not None:
3603 
      return result.success
3604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateAccessToken failed: unknown result");
3605 
 
17782 amit.gupta 3606 
  def addItemsToCart(self, cartId, itemQty, couponCode):
3607 
    """
3608 
    Parameters:
3609 
     - cartId
3610 
     - itemQty
3611 
     - couponCode
3612 
    """
3613 
    self.send_addItemsToCart(cartId, itemQty, couponCode)
3614 
    return self.recv_addItemsToCart()
15251 manish.sha 3615 
 
17782 amit.gupta 3616 
  def send_addItemsToCart(self, cartId, itemQty, couponCode):
3617 
    self._oprot.writeMessageBegin('addItemsToCart', TMessageType.CALL, self._seqid)
3618 
    args = addItemsToCart_args()
3619 
    args.cartId = cartId
3620 
    args.itemQty = itemQty
3621 
    args.couponCode = couponCode
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_addItemsToCart(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = addItemsToCart_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3636 
    if result.success is not None:
3637 
      return result.success
3638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsToCart failed: unknown result");
3639 
 
3640 
  def validateCartNew(self, cartId, pinCode, sourceId):
3641 
    """
3642 
    Parameters:
3643 
     - cartId
3644 
     - pinCode
3645 
     - sourceId
3646 
    """
3647 
    self.send_validateCartNew(cartId, pinCode, sourceId)
3648 
    return self.recv_validateCartNew()
3649 
 
3650 
  def send_validateCartNew(self, cartId, pinCode, sourceId):
3651 
    self._oprot.writeMessageBegin('validateCartNew', TMessageType.CALL, self._seqid)
3652 
    args = validateCartNew_args()
3653 
    args.cartId = cartId
3654 
    args.pinCode = pinCode
3655 
    args.sourceId = sourceId
3656 
    args.write(self._oprot)
3657 
    self._oprot.writeMessageEnd()
3658 
    self._oprot.trans.flush()
3659 
 
3660 
  def recv_validateCartNew(self, ):
3661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3662 
    if mtype == TMessageType.EXCEPTION:
3663 
      x = TApplicationException()
3664 
      x.read(self._iprot)
3665 
      self._iprot.readMessageEnd()
3666 
      raise x
3667 
    result = validateCartNew_result()
3668 
    result.read(self._iprot)
3669 
    self._iprot.readMessageEnd()
3670 
    if result.success is not None:
3671 
      return result.success
3672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCartNew failed: unknown result");
3673 
 
18644 manish.sha 3674 
  def isAddressEditableForCounter(self, userId):
18530 manish.sha 3675 
    """
3676 
    Parameters:
3677 
     - userId
3678 
    """
18644 manish.sha 3679 
    self.send_isAddressEditableForCounter(userId)
3680 
    return self.recv_isAddressEditableForCounter()
17782 amit.gupta 3681 
 
18644 manish.sha 3682 
  def send_isAddressEditableForCounter(self, userId):
3683 
    self._oprot.writeMessageBegin('isAddressEditableForCounter', TMessageType.CALL, self._seqid)
3684 
    args = isAddressEditableForCounter_args()
18530 manish.sha 3685 
    args.userId = userId
3686 
    args.write(self._oprot)
3687 
    self._oprot.writeMessageEnd()
3688 
    self._oprot.trans.flush()
3689 
 
18644 manish.sha 3690 
  def recv_isAddressEditableForCounter(self, ):
18530 manish.sha 3691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3692 
    if mtype == TMessageType.EXCEPTION:
3693 
      x = TApplicationException()
3694 
      x.read(self._iprot)
3695 
      self._iprot.readMessageEnd()
3696 
      raise x
18644 manish.sha 3697 
    result = isAddressEditableForCounter_result()
18530 manish.sha 3698 
    result.read(self._iprot)
3699 
    self._iprot.readMessageEnd()
3700 
    if result.success is not None:
3701 
      return result.success
18644 manish.sha 3702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isAddressEditableForCounter failed: unknown result");
18530 manish.sha 3703 
 
3704 
  def getBillingAddressForUser(self, userId):
3705 
    """
3706 
    Parameters:
3707 
     - userId
3708 
    """
3709 
    self.send_getBillingAddressForUser(userId)
3710 
    return self.recv_getBillingAddressForUser()
3711 
 
3712 
  def send_getBillingAddressForUser(self, userId):
3713 
    self._oprot.writeMessageBegin('getBillingAddressForUser', TMessageType.CALL, self._seqid)
3714 
    args = getBillingAddressForUser_args()
3715 
    args.userId = userId
3716 
    args.write(self._oprot)
3717 
    self._oprot.writeMessageEnd()
3718 
    self._oprot.trans.flush()
3719 
 
3720 
  def recv_getBillingAddressForUser(self, ):
3721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3722 
    if mtype == TMessageType.EXCEPTION:
3723 
      x = TApplicationException()
3724 
      x.read(self._iprot)
3725 
      self._iprot.readMessageEnd()
3726 
      raise x
3727 
    result = getBillingAddressForUser_result()
3728 
    result.read(self._iprot)
3729 
    self._iprot.readMessageEnd()
3730 
    if result.success is not None:
3731 
      return result.success
3732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillingAddressForUser failed: unknown result");
3733 
 
18590 manish.sha 3734 
  def isCreditorAssigned(self, userId):
3735 
    """
3736 
    Parameters:
3737 
     - userId
3738 
    """
3739 
    self.send_isCreditorAssigned(userId)
3740 
    return self.recv_isCreditorAssigned()
18530 manish.sha 3741 
 
18590 manish.sha 3742 
  def send_isCreditorAssigned(self, userId):
3743 
    self._oprot.writeMessageBegin('isCreditorAssigned', TMessageType.CALL, self._seqid)
3744 
    args = isCreditorAssigned_args()
3745 
    args.userId = userId
3746 
    args.write(self._oprot)
3747 
    self._oprot.writeMessageEnd()
3748 
    self._oprot.trans.flush()
3749 
 
3750 
  def recv_isCreditorAssigned(self, ):
3751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3752 
    if mtype == TMessageType.EXCEPTION:
3753 
      x = TApplicationException()
3754 
      x.read(self._iprot)
3755 
      self._iprot.readMessageEnd()
3756 
      raise x
3757 
    result = isCreditorAssigned_result()
3758 
    result.read(self._iprot)
3759 
    self._iprot.readMessageEnd()
3760 
    if result.success is not None:
3761 
      return result.success
3762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isCreditorAssigned failed: unknown result");
3763 
 
18735 manish.sha 3764 
  def isTaxInvoiceEnabledUser(self, userId):
3765 
    """
3766 
    Parameters:
3767 
     - userId
3768 
    """
3769 
    self.send_isTaxInvoiceEnabledUser(userId)
3770 
    return self.recv_isTaxInvoiceEnabledUser()
18590 manish.sha 3771 
 
18735 manish.sha 3772 
  def send_isTaxInvoiceEnabledUser(self, userId):
3773 
    self._oprot.writeMessageBegin('isTaxInvoiceEnabledUser', TMessageType.CALL, self._seqid)
3774 
    args = isTaxInvoiceEnabledUser_args()
3775 
    args.userId = userId
3776 
    args.write(self._oprot)
3777 
    self._oprot.writeMessageEnd()
3778 
    self._oprot.trans.flush()
3779 
 
3780 
  def recv_isTaxInvoiceEnabledUser(self, ):
3781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3782 
    if mtype == TMessageType.EXCEPTION:
3783 
      x = TApplicationException()
3784 
      x.read(self._iprot)
3785 
      self._iprot.readMessageEnd()
3786 
      raise x
3787 
    result = isTaxInvoiceEnabledUser_result()
3788 
    result.read(self._iprot)
3789 
    self._iprot.readMessageEnd()
3790 
    if result.success is not None:
3791 
      return result.success
3792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTaxInvoiceEnabledUser failed: unknown result");
3793 
 
18764 kshitij.so 3794 
  def getCartByValue(self, cartIds):
3795 
    """
3796 
    Parameters:
3797 
     - cartIds
3798 
    """
3799 
    self.send_getCartByValue(cartIds)
3800 
    return self.recv_getCartByValue()
18735 manish.sha 3801 
 
18764 kshitij.so 3802 
  def send_getCartByValue(self, cartIds):
3803 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
3804 
    args = getCartByValue_args()
3805 
    args.cartIds = cartIds
3806 
    args.write(self._oprot)
3807 
    self._oprot.writeMessageEnd()
3808 
    self._oprot.trans.flush()
3809 
 
3810 
  def recv_getCartByValue(self, ):
3811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3812 
    if mtype == TMessageType.EXCEPTION:
3813 
      x = TApplicationException()
3814 
      x.read(self._iprot)
3815 
      self._iprot.readMessageEnd()
3816 
      raise x
3817 
    result = getCartByValue_result()
3818 
    result.read(self._iprot)
3819 
    self._iprot.readMessageEnd()
3820 
    if result.success is not None:
3821 
      return result.success
3822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
3823 
 
3824 
 
3376 rajveer 3825 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 3826 
  def __init__(self, handler):
3376 rajveer 3827 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 3828 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
3829 
    self._processMap["getUserById"] = Processor.process_getUserById
5326 rajveer 3830 
    self._processMap["getUserByCartId"] = Processor.process_getUserByCartId
1491 vikas 3831 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 3832 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 3833 
    self._processMap["createUser"] = Processor.process_createUser
3834 
    self._processMap["updateUser"] = Processor.process_updateUser
122 ashish 3835 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 3836 
    self._processMap["userExists"] = Processor.process_userExists
3837 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
3838 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
3839 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
3840 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 3841 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 3842 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 3843 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 3844 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 3845 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 3846 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 3847 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 3848 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 3849 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
3850 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
3851 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
5407 amar.kumar 3852 
    self._processMap["removeUserCommunication"] = Processor.process_removeUserCommunication
1845 vikas 3853 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 3854 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 3855 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
3856 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
3857 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
3858 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
3859 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 3860 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 3861 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
3862 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
3863 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 3864 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 3865 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
3866 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 3867 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
3868 
    self._processMap["getCart"] = Processor.process_getCart
3869 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
3870 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
3871 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
3872 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
5553 rajveer 3873 
    self._processMap["addStoreToCart"] = Processor.process_addStoreToCart
1976 varun.gupt 3874 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
3875 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
3554 varun.gupt 3876 
    self._processMap["deleteDiscountsFromCart"] = Processor.process_deleteDiscountsFromCart
3877 
    self._processMap["saveDiscounts"] = Processor.process_saveDiscounts
690 chandransh 3878 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 3879 
    self._processMap["validateCart"] = Processor.process_validateCart
11980 amit.gupta 3880 
    self._processMap["validateCartWithDealerCoupon"] = Processor.process_validateCartWithDealerCoupon
559 chandransh 3881 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 3882 
    self._processMap["checkOut"] = Processor.process_checkOut
3883 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 3884 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 3885 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2981 rajveer 3886 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
3887 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
3888 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
3889 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
3890 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 3891 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
3499 mandeep.dh 3892 
    self._processMap["increaseTrustLevel"] = Processor.process_increaseTrustLevel
5407 amar.kumar 3893 
    self._processMap["getTrustLevel"] = Processor.process_getTrustLevel
4668 varun.gupt 3894 
    self._processMap["showCODOption"] = Processor.process_showCODOption
5623 anupam.sin 3895 
    self._processMap["getUserEmails"] = Processor.process_getUserEmails
6903 anupam.sin 3896 
    self._processMap["insureItem"] = Processor.process_insureItem
3897 
    self._processMap["cancelInsurance"] = Processor.process_cancelInsurance
3898 
    self._processMap["storeInsuranceSpecificDetails"] = Processor.process_storeInsuranceSpecificDetails
3899 
    self._processMap["isInsuranceDetailPresent"] = Processor.process_isInsuranceDetailPresent
9791 rajveer 3900 
    self._processMap["getProductsAddedToCart"] = Processor.process_getProductsAddedToCart
11592 amit.gupta 3901 
    self._processMap["validateCartPlus"] = Processor.process_validateCartPlus
11679 vikram.rag 3902 
    self._processMap["isPrivateDealUser"] = Processor.process_isPrivateDealUser
11890 kshitij.so 3903 
    self._processMap["addPrivateDealUser"] = Processor.process_addPrivateDealUser
3904 
    self._processMap["changePrivateDealUserStatus"] = Processor.process_changePrivateDealUserStatus
3905 
    self._processMap["getPrivateDealUser"] = Processor.process_getPrivateDealUser
12696 amit.gupta 3906 
    self._processMap["registerCounter"] = Processor.process_registerCounter
12722 amit.gupta 3907 
    self._processMap["searchCounter"] = Processor.process_searchCounter
18977 amit.gupta 3908 
    self._processMap["getCounterByUserId"] = Processor.process_getCounterByUserId
12722 amit.gupta 3909 
    self._processMap["getAllUsersByCounter"] = Processor.process_getAllUsersByCounter
15251 manish.sha 3910 
    self._processMap["getActiveAccessTokenForUser"] = Processor.process_getActiveAccessTokenForUser
3911 
    self._processMap["validateAccessToken"] = Processor.process_validateAccessToken
17782 amit.gupta 3912 
    self._processMap["addItemsToCart"] = Processor.process_addItemsToCart
3913 
    self._processMap["validateCartNew"] = Processor.process_validateCartNew
18644 manish.sha 3914 
    self._processMap["isAddressEditableForCounter"] = Processor.process_isAddressEditableForCounter
18530 manish.sha 3915 
    self._processMap["getBillingAddressForUser"] = Processor.process_getBillingAddressForUser
18590 manish.sha 3916 
    self._processMap["isCreditorAssigned"] = Processor.process_isCreditorAssigned
18735 manish.sha 3917 
    self._processMap["isTaxInvoiceEnabledUser"] = Processor.process_isTaxInvoiceEnabledUser
18764 kshitij.so 3918 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
94 ashish 3919 
 
3920 
  def process(self, iprot, oprot):
3921 
    (name, type, seqid) = iprot.readMessageBegin()
3922 
    if name not in self._processMap:
3923 
      iprot.skip(TType.STRUCT)
3924 
      iprot.readMessageEnd()
3925 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3926 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3927 
      x.write(oprot)
3928 
      oprot.writeMessageEnd()
3929 
      oprot.trans.flush()
3930 
      return
3931 
    else:
3932 
      self._processMap[name](self, seqid, iprot, oprot)
3933 
    return True
3934 
 
559 chandransh 3935 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
3936 
    args = createAnonymousUser_args()
94 ashish 3937 
    args.read(iprot)
3938 
    iprot.readMessageEnd()
559 chandransh 3939 
    result = createAnonymousUser_result()
94 ashish 3940 
    try:
559 chandransh 3941 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
3942 
    except UserContextException, ucex:
3943 
      result.ucex = ucex
3944 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 3945 
    result.write(oprot)
3946 
    oprot.writeMessageEnd()
3947 
    oprot.trans.flush()
3948 
 
559 chandransh 3949 
  def process_getUserById(self, seqid, iprot, oprot):
3950 
    args = getUserById_args()
94 ashish 3951 
    args.read(iprot)
3952 
    iprot.readMessageEnd()
559 chandransh 3953 
    result = getUserById_result()
94 ashish 3954 
    try:
559 chandransh 3955 
      result.success = self._handler.getUserById(args.userId)
3956 
    except UserContextException, ucex:
3957 
      result.ucex = ucex
3958 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 3959 
    result.write(oprot)
3960 
    oprot.writeMessageEnd()
3961 
    oprot.trans.flush()
3962 
 
5326 rajveer 3963 
  def process_getUserByCartId(self, seqid, iprot, oprot):
3964 
    args = getUserByCartId_args()
3965 
    args.read(iprot)
3966 
    iprot.readMessageEnd()
3967 
    result = getUserByCartId_result()
3968 
    try:
3969 
      result.success = self._handler.getUserByCartId(args.cartId)
3970 
    except UserContextException, ucex:
3971 
      result.ucex = ucex
3972 
    oprot.writeMessageBegin("getUserByCartId", TMessageType.REPLY, seqid)
3973 
    result.write(oprot)
3974 
    oprot.writeMessageEnd()
3975 
    oprot.trans.flush()
3976 
 
1491 vikas 3977 
  def process_getUserByEmail(self, seqid, iprot, oprot):
3978 
    args = getUserByEmail_args()
3979 
    args.read(iprot)
3980 
    iprot.readMessageEnd()
3981 
    result = getUserByEmail_result()
3982 
    try:
3983 
      result.success = self._handler.getUserByEmail(args.email)
3984 
    except UserContextException, ucex:
3985 
      result.ucex = ucex
3986 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3987 
    result.write(oprot)
3988 
    oprot.writeMessageEnd()
3989 
    oprot.trans.flush()
3990 
 
3032 mandeep.dh 3991 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3992 
    args = getUserByMobileNumber_args()
3993 
    args.read(iprot)
3994 
    iprot.readMessageEnd()
3995 
    result = getUserByMobileNumber_result()
3996 
    try:
3997 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3998 
    except UserContextException, ucex:
3999 
      result.ucex = ucex
4000 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
4001 
    result.write(oprot)
4002 
    oprot.writeMessageEnd()
4003 
    oprot.trans.flush()
4004 
 
559 chandransh 4005 
  def process_createUser(self, seqid, iprot, oprot):
4006 
    args = createUser_args()
94 ashish 4007 
    args.read(iprot)
4008 
    iprot.readMessageEnd()
559 chandransh 4009 
    result = createUser_result()
94 ashish 4010 
    try:
559 chandransh 4011 
      result.success = self._handler.createUser(args.user)
4012 
    except UserContextException, ucex:
4013 
      result.ucex = ucex
4014 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 4015 
    result.write(oprot)
4016 
    oprot.writeMessageEnd()
4017 
    oprot.trans.flush()
4018 
 
559 chandransh 4019 
  def process_updateUser(self, seqid, iprot, oprot):
4020 
    args = updateUser_args()
94 ashish 4021 
    args.read(iprot)
4022 
    iprot.readMessageEnd()
559 chandransh 4023 
    result = updateUser_result()
94 ashish 4024 
    try:
559 chandransh 4025 
      result.success = self._handler.updateUser(args.user)
4026 
    except UserContextException, ucex:
4027 
      result.ucex = ucex
4028 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 4029 
    result.write(oprot)
4030 
    oprot.writeMessageEnd()
4031 
    oprot.trans.flush()
4032 
 
122 ashish 4033 
  def process_authenticateUser(self, seqid, iprot, oprot):
4034 
    args = authenticateUser_args()
4035 
    args.read(iprot)
4036 
    iprot.readMessageEnd()
4037 
    result = authenticateUser_result()
4038 
    try:
559 chandransh 4039 
      result.success = self._handler.authenticateUser(args.email, args.password)
4040 
    except AuthenticationException, auex:
4041 
      result.auex = auex
122 ashish 4042 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
4043 
    result.write(oprot)
4044 
    oprot.writeMessageEnd()
4045 
    oprot.trans.flush()
4046 
 
94 ashish 4047 
  def process_userExists(self, seqid, iprot, oprot):
4048 
    args = userExists_args()
4049 
    args.read(iprot)
4050 
    iprot.readMessageEnd()
4051 
    result = userExists_result()
4052 
    try:
4053 
      result.success = self._handler.userExists(args.email)
4054 
    except UserContextException, ucx:
4055 
      result.ucx = ucx
4056 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
4060 
 
4061 
  def process_addAddressForUser(self, seqid, iprot, oprot):
4062 
    args = addAddressForUser_args()
4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
4065 
    result = addAddressForUser_result()
4066 
    try:
567 rajveer 4067 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 4068 
    except UserContextException, ucx:
4069 
      result.ucx = ucx
4070 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
4071 
    result.write(oprot)
4072 
    oprot.writeMessageEnd()
4073 
    oprot.trans.flush()
4074 
 
4075 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
4076 
    args = removeAddressForUser_args()
4077 
    args.read(iprot)
4078 
    iprot.readMessageEnd()
4079 
    result = removeAddressForUser_result()
4080 
    try:
4081 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
4082 
    except UserContextException, ucx:
4083 
      result.ucx = ucx
4084 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
4089 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
4090 
    args = setUserAsLoggedIn_args()
4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4093 
    result = setUserAsLoggedIn_result()
4094 
    try:
4095 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
4096 
    except UserContextException, ucx:
4097 
      result.ucx = ucx
4098 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
4099 
    result.write(oprot)
4100 
    oprot.writeMessageEnd()
4101 
    oprot.trans.flush()
4102 
 
4103 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
4104 
    args = setUserAsLoggedOut_args()
4105 
    args.read(iprot)
4106 
    iprot.readMessageEnd()
4107 
    result = setUserAsLoggedOut_result()
4108 
    try:
4109 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
4110 
    except UserContextException, ucx:
4111 
      result.ucx = ucx
4112 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
4113 
    result.write(oprot)
4114 
    oprot.writeMessageEnd()
4115 
    oprot.trans.flush()
4116 
 
504 rajveer 4117 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
4118 
    args = setDefaultAddress_args()
4119 
    args.read(iprot)
4120 
    iprot.readMessageEnd()
4121 
    result = setDefaultAddress_result()
4122 
    try:
4123 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
4124 
    except UserContextException, ucx:
4125 
      result.ucx = ucx
4126 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
4127 
    result.write(oprot)
4128 
    oprot.writeMessageEnd()
4129 
    oprot.trans.flush()
4130 
 
94 ashish 4131 
  def process_updatePassword(self, seqid, iprot, oprot):
4132 
    args = updatePassword_args()
4133 
    args.read(iprot)
4134 
    iprot.readMessageEnd()
4135 
    result = updatePassword_result()
4136 
    try:
594 rajveer 4137 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 4138 
    except UserContextException, ucx:
4139 
      result.ucx = ucx
4140 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
4141 
    result.write(oprot)
4142 
    oprot.writeMessageEnd()
4143 
    oprot.trans.flush()
4144 
 
581 rajveer 4145 
  def process_forgotPassword(self, seqid, iprot, oprot):
4146 
    args = forgotPassword_args()
4147 
    args.read(iprot)
4148 
    iprot.readMessageEnd()
4149 
    result = forgotPassword_result()
4150 
    try:
884 rajveer 4151 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 4152 
    except UserContextException, ucx:
4153 
      result.ucx = ucx
4154 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
4158 
 
594 rajveer 4159 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
4160 
    args = getAllAddressesForUser_args()
4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
4163 
    result = getAllAddressesForUser_result()
4164 
    try:
4165 
      result.success = self._handler.getAllAddressesForUser(args.userId)
4166 
    except UserContextException, ucx:
4167 
      result.ucx = ucx
4168 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
4169 
    result.write(oprot)
4170 
    oprot.writeMessageEnd()
4171 
    oprot.trans.flush()
4172 
 
1894 vikas 4173 
  def process_getAddressById(self, seqid, iprot, oprot):
4174 
    args = getAddressById_args()
4175 
    args.read(iprot)
4176 
    iprot.readMessageEnd()
4177 
    result = getAddressById_result()
4178 
    try:
4179 
      result.success = self._handler.getAddressById(args.addressId)
4180 
    except UserContextException, ucx:
4181 
      result.ucx = ucx
4182 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
4183 
    result.write(oprot)
4184 
    oprot.writeMessageEnd()
4185 
    oprot.trans.flush()
4186 
 
594 rajveer 4187 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
4188 
    args = getDefaultAddressId_args()
4189 
    args.read(iprot)
4190 
    iprot.readMessageEnd()
4191 
    result = getDefaultAddressId_result()
4192 
    try:
4193 
      result.success = self._handler.getDefaultAddressId(args.userId)
4194 
    except UserContextException, ucx:
4195 
      result.ucx = ucx
4196 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
4200 
 
785 rajveer 4201 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
4202 
    args = getDefaultPincode_args()
4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
4205 
    result = getDefaultPincode_result()
4206 
    try:
4207 
      result.success = self._handler.getDefaultPincode(args.userId)
4208 
    except UserContextException, ucx:
4209 
      result.ucx = ucx
4210 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
4211 
    result.write(oprot)
4212 
    oprot.writeMessageEnd()
4213 
    oprot.trans.flush()
4214 
 
1274 varun.gupt 4215 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
4216 
    args = saveUserCommunication_args()
4217 
    args.read(iprot)
4218 
    iprot.readMessageEnd()
4219 
    result = saveUserCommunication_result()
4220 
    try:
4221 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
4222 
    except UserCommunicationException, ucx:
4223 
      result.ucx = ucx
4224 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
4225 
    result.write(oprot)
4226 
    oprot.writeMessageEnd()
4227 
    oprot.trans.flush()
4228 
 
1590 varun.gupt 4229 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
4230 
    args = getUserCommunicationById_args()
4231 
    args.read(iprot)
4232 
    iprot.readMessageEnd()
4233 
    result = getUserCommunicationById_result()
4234 
    try:
4235 
      result.success = self._handler.getUserCommunicationById(args.id)
4236 
    except UserCommunicationException, ucx:
4237 
      result.ucx = ucx
4238 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
4239 
    result.write(oprot)
4240 
    oprot.writeMessageEnd()
4241 
    oprot.trans.flush()
4242 
 
4243 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
4244 
    args = getUserCommunicationByUser_args()
4245 
    args.read(iprot)
4246 
    iprot.readMessageEnd()
4247 
    result = getUserCommunicationByUser_result()
4248 
    try:
4249 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
4250 
    except UserCommunicationException, ucx:
4251 
      result.ucx = ucx
4252 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
4253 
    result.write(oprot)
4254 
    oprot.writeMessageEnd()
4255 
    oprot.trans.flush()
4256 
 
4257 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
4258 
    args = getAllUserCommunications_args()
4259 
    args.read(iprot)
4260 
    iprot.readMessageEnd()
4261 
    result = getAllUserCommunications_result()
4262 
    try:
4263 
      result.success = self._handler.getAllUserCommunications()
4264 
    except UserCommunicationException, ucx:
4265 
      result.ucx = ucx
4266 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
4267 
    result.write(oprot)
4268 
    oprot.writeMessageEnd()
4269 
    oprot.trans.flush()
4270 
 
5407 amar.kumar 4271 
  def process_removeUserCommunication(self, seqid, iprot, oprot):
4272 
    args = removeUserCommunication_args()
4273 
    args.read(iprot)
4274 
    iprot.readMessageEnd()
4275 
    result = removeUserCommunication_result()
4276 
    try:
4277 
      self._handler.removeUserCommunication(args.id)
4278 
    except UserCommunicationException, ucx:
4279 
      result.ucx = ucx
4280 
    oprot.writeMessageBegin("removeUserCommunication", TMessageType.REPLY, seqid)
4281 
    result.write(oprot)
4282 
    oprot.writeMessageEnd()
4283 
    oprot.trans.flush()
4284 
 
1845 vikas 4285 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
4286 
    args = createMasterAffiliate_args()
4287 
    args.read(iprot)
4288 
    iprot.readMessageEnd()
4289 
    result = createMasterAffiliate_result()
4290 
    try:
1859 vikas 4291 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 4292 
    except UserAffiliateException, utx:
1845 vikas 4293 
      result.utx = utx
4294 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
4295 
    result.write(oprot)
4296 
    oprot.writeMessageEnd()
4297 
    oprot.trans.flush()
4298 
 
1899 vikas 4299 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
4300 
    args = getAllMasterAffiliates_args()
4301 
    args.read(iprot)
4302 
    iprot.readMessageEnd()
4303 
    result = getAllMasterAffiliates_result()
4304 
    try:
4305 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 4306 
    except UserAffiliateException, utx:
1899 vikas 4307 
      result.utx = utx
4308 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
4309 
    result.write(oprot)
4310 
    oprot.writeMessageEnd()
4311 
    oprot.trans.flush()
4312 
 
1845 vikas 4313 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
4314 
    args = getMasterAffiliateById_args()
4315 
    args.read(iprot)
4316 
    iprot.readMessageEnd()
4317 
    result = getMasterAffiliateById_result()
4318 
    try:
4319 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 4320 
    except UserAffiliateException, utx:
1845 vikas 4321 
      result.utx = utx
4322 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
4323 
    result.write(oprot)
4324 
    oprot.writeMessageEnd()
4325 
    oprot.trans.flush()
4326 
 
4327 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
4328 
    args = getMasterAffiliateByName_args()
4329 
    args.read(iprot)
4330 
    iprot.readMessageEnd()
4331 
    result = getMasterAffiliateByName_result()
4332 
    try:
4333 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 4334 
    except UserAffiliateException, utx:
1845 vikas 4335 
      result.utx = utx
4336 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
4337 
    result.write(oprot)
4338 
    oprot.writeMessageEnd()
4339 
    oprot.trans.flush()
4340 
 
4341 
  def process_createAffiliate(self, seqid, iprot, oprot):
4342 
    args = createAffiliate_args()
4343 
    args.read(iprot)
4344 
    iprot.readMessageEnd()
4345 
    result = createAffiliate_result()
4346 
    try:
1859 vikas 4347 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 4348 
    except UserAffiliateException, utx:
1845 vikas 4349 
      result.utx = utx
4350 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
4351 
    result.write(oprot)
4352 
    oprot.writeMessageEnd()
4353 
    oprot.trans.flush()
4354 
 
4355 
  def process_getAffiliateById(self, seqid, iprot, oprot):
4356 
    args = getAffiliateById_args()
4357 
    args.read(iprot)
4358 
    iprot.readMessageEnd()
4359 
    result = getAffiliateById_result()
4360 
    try:
4361 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 4362 
    except UserAffiliateException, utx:
1845 vikas 4363 
      result.utx = utx
4364 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
4365 
    result.write(oprot)
4366 
    oprot.writeMessageEnd()
4367 
    oprot.trans.flush()
4368 
 
4369 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
4370 
    args = getAffiliateByName_args()
4371 
    args.read(iprot)
4372 
    iprot.readMessageEnd()
4373 
    result = getAffiliateByName_result()
4374 
    try:
4375 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 4376 
    except UserAffiliateException, utx:
1845 vikas 4377 
      result.utx = utx
4378 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
4379 
    result.write(oprot)
4380 
    oprot.writeMessageEnd()
4381 
    oprot.trans.flush()
4382 
 
4383 
  def process_getTrackerById(self, seqid, iprot, oprot):
4384 
    args = getTrackerById_args()
4385 
    args.read(iprot)
4386 
    iprot.readMessageEnd()
4387 
    result = getTrackerById_result()
4388 
    try:
1996 vikas 4389 
      result.success = self._handler.getTrackerById(args.id)
4390 
    except UserAffiliateException, utx:
1845 vikas 4391 
      result.utx = utx
4392 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
4393 
    result.write(oprot)
4394 
    oprot.writeMessageEnd()
4395 
    oprot.trans.flush()
4396 
 
1996 vikas 4397 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
4398 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 4399 
    args.read(iprot)
4400 
    iprot.readMessageEnd()
1996 vikas 4401 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 4402 
    try:
1996 vikas 4403 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
4404 
    except UserAffiliateException, utx:
1845 vikas 4405 
      result.utx = utx
1996 vikas 4406 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4407 
    result.write(oprot)
4408 
    oprot.writeMessageEnd()
4409 
    oprot.trans.flush()
4410 
 
4411 
  def process_addTrackLog(self, seqid, iprot, oprot):
4412 
    args = addTrackLog_args()
4413 
    args.read(iprot)
4414 
    iprot.readMessageEnd()
4415 
    result = addTrackLog_result()
4416 
    try:
1996 vikas 4417 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
4418 
    except UserAffiliateException, utx:
1845 vikas 4419 
      result.utx = utx
4420 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
4421 
    result.write(oprot)
4422 
    oprot.writeMessageEnd()
4423 
    oprot.trans.flush()
4424 
 
4425 
  def process_getTrackLogById(self, seqid, iprot, oprot):
4426 
    args = getTrackLogById_args()
4427 
    args.read(iprot)
4428 
    iprot.readMessageEnd()
4429 
    result = getTrackLogById_result()
4430 
    try:
4431 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 4432 
    except UserAffiliateException, utx:
1845 vikas 4433 
      result.utx = utx
4434 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
4435 
    result.write(oprot)
4436 
    oprot.writeMessageEnd()
4437 
    oprot.trans.flush()
4438 
 
1996 vikas 4439 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
4440 
    args = getTrackLogsByAffiliate_args()
1845 vikas 4441 
    args.read(iprot)
4442 
    iprot.readMessageEnd()
1996 vikas 4443 
    result = getTrackLogsByAffiliate_result()
1845 vikas 4444 
    try:
3293 vikas 4445 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 4446 
    except UserAffiliateException, utx:
1845 vikas 4447 
      result.utx = utx
1996 vikas 4448 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 4449 
    result.write(oprot)
4450 
    oprot.writeMessageEnd()
4451 
    oprot.trans.flush()
4452 
 
4453 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
4454 
    args = getTrackLogsByUser_args()
4455 
    args.read(iprot)
4456 
    iprot.readMessageEnd()
4457 
    result = getTrackLogsByUser_result()
4458 
    try:
4459 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 4460 
    except UserAffiliateException, utx:
1845 vikas 4461 
      result.utx = utx
4462 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
4463 
    result.write(oprot)
4464 
    oprot.writeMessageEnd()
4465 
    oprot.trans.flush()
4466 
 
4467 
  def process_getTrackLogs(self, seqid, iprot, oprot):
4468 
    args = getTrackLogs_args()
4469 
    args.read(iprot)
4470 
    iprot.readMessageEnd()
4471 
    result = getTrackLogs_result()
4472 
    try:
1996 vikas 4473 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
4474 
    except UserAffiliateException, utx:
1845 vikas 4475 
      result.utx = utx
4476 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
4477 
    result.write(oprot)
4478 
    oprot.writeMessageEnd()
4479 
    oprot.trans.flush()
4480 
 
559 chandransh 4481 
  def process_getCurrentCart(self, seqid, iprot, oprot):
4482 
    args = getCurrentCart_args()
94 ashish 4483 
    args.read(iprot)
4484 
    iprot.readMessageEnd()
559 chandransh 4485 
    result = getCurrentCart_result()
94 ashish 4486 
    try:
559 chandransh 4487 
      result.success = self._handler.getCurrentCart(args.userId)
4488 
    except ShoppingCartException, scx:
4489 
      result.scx = scx
4490 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 4491 
    result.write(oprot)
4492 
    oprot.writeMessageEnd()
4493 
    oprot.trans.flush()
4494 
 
559 chandransh 4495 
  def process_getCart(self, seqid, iprot, oprot):
4496 
    args = getCart_args()
94 ashish 4497 
    args.read(iprot)
4498 
    iprot.readMessageEnd()
559 chandransh 4499 
    result = getCart_result()
94 ashish 4500 
    try:
559 chandransh 4501 
      result.success = self._handler.getCart(args.cartId)
4502 
    except ShoppingCartException, scx:
4503 
      result.scx = scx
4504 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
4508 
 
559 chandransh 4509 
  def process_getCartsByTime(self, seqid, iprot, oprot):
4510 
    args = getCartsByTime_args()
94 ashish 4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
559 chandransh 4513 
    result = getCartsByTime_result()
94 ashish 4514 
    try:
559 chandransh 4515 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
4516 
    except ShoppingCartException, scx:
4517 
      result.scx = scx
4518 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 4519 
    result.write(oprot)
4520 
    oprot.writeMessageEnd()
4521 
    oprot.trans.flush()
4522 
 
559 chandransh 4523 
  def process_addItemToCart(self, seqid, iprot, oprot):
4524 
    args = addItemToCart_args()
130 ashish 4525 
    args.read(iprot)
4526 
    iprot.readMessageEnd()
559 chandransh 4527 
    result = addItemToCart_result()
130 ashish 4528 
    try:
3557 rajveer 4529 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity, args.sourceId)
559 chandransh 4530 
    except ShoppingCartException, scx:
4531 
      result.scx = scx
4532 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 4533 
    result.write(oprot)
4534 
    oprot.writeMessageEnd()
4535 
    oprot.trans.flush()
4536 
 
559 chandransh 4537 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
4538 
    args = deleteItemFromCart_args()
4539 
    args.read(iprot)
4540 
    iprot.readMessageEnd()
4541 
    result = deleteItemFromCart_result()
4542 
    try:
4543 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
4544 
    except ShoppingCartException, scx:
4545 
      result.scx = scx
4546 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
4547 
    result.write(oprot)
4548 
    oprot.writeMessageEnd()
4549 
    oprot.trans.flush()
130 ashish 4550 
 
559 chandransh 4551 
  def process_addAddressToCart(self, seqid, iprot, oprot):
4552 
    args = addAddressToCart_args()
4553 
    args.read(iprot)
4554 
    iprot.readMessageEnd()
4555 
    result = addAddressToCart_result()
575 chandransh 4556 
    try:
4557 
      self._handler.addAddressToCart(args.cartId, args.addressId)
4558 
    except ShoppingCartException, scx:
4559 
      result.scx = scx
559 chandransh 4560 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
4561 
    result.write(oprot)
4562 
    oprot.writeMessageEnd()
4563 
    oprot.trans.flush()
4564 
 
5553 rajveer 4565 
  def process_addStoreToCart(self, seqid, iprot, oprot):
4566 
    args = addStoreToCart_args()
4567 
    args.read(iprot)
4568 
    iprot.readMessageEnd()
4569 
    result = addStoreToCart_result()
4570 
    try:
4571 
      self._handler.addStoreToCart(args.cartId, args.storeId)
4572 
    except ShoppingCartException, scx:
4573 
      result.scx = scx
4574 
    oprot.writeMessageBegin("addStoreToCart", TMessageType.REPLY, seqid)
4575 
    result.write(oprot)
4576 
    oprot.writeMessageEnd()
4577 
    oprot.trans.flush()
4578 
 
1976 varun.gupt 4579 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
4580 
    args = applyCouponToCart_args()
4581 
    args.read(iprot)
4582 
    iprot.readMessageEnd()
4583 
    result = applyCouponToCart_result()
4584 
    try:
6922 anupam.sin 4585 
      self._handler.applyCouponToCart(args.cart, args.couponCode)
1976 varun.gupt 4586 
    except ShoppingCartException, scx:
4587 
      result.scx = scx
4588 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
4589 
    result.write(oprot)
4590 
    oprot.writeMessageEnd()
4591 
    oprot.trans.flush()
4592 
 
4593 
  def process_removeCoupon(self, seqid, iprot, oprot):
4594 
    args = removeCoupon_args()
4595 
    args.read(iprot)
4596 
    iprot.readMessageEnd()
4597 
    result = removeCoupon_result()
4598 
    try:
4599 
      self._handler.removeCoupon(args.cartId)
4600 
    except ShoppingCartException, scx:
4601 
      result.scx = scx
4602 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
4603 
    result.write(oprot)
4604 
    oprot.writeMessageEnd()
4605 
    oprot.trans.flush()
4606 
 
3554 varun.gupt 4607 
  def process_deleteDiscountsFromCart(self, seqid, iprot, oprot):
4608 
    args = deleteDiscountsFromCart_args()
4609 
    args.read(iprot)
4610 
    iprot.readMessageEnd()
4611 
    result = deleteDiscountsFromCart_result()
4612 
    try:
4613 
      self._handler.deleteDiscountsFromCart(args.cartId)
4614 
    except ShoppingCartException, scx:
4615 
      result.scx = scx
4616 
    oprot.writeMessageBegin("deleteDiscountsFromCart", TMessageType.REPLY, seqid)
4617 
    result.write(oprot)
4618 
    oprot.writeMessageEnd()
4619 
    oprot.trans.flush()
4620 
 
4621 
  def process_saveDiscounts(self, seqid, iprot, oprot):
4622 
    args = saveDiscounts_args()
4623 
    args.read(iprot)
4624 
    iprot.readMessageEnd()
4625 
    result = saveDiscounts_result()
4626 
    try:
4627 
      self._handler.saveDiscounts(args.discounts)
4628 
    except ShoppingCartException, scx:
4629 
      result.scx = scx
4630 
    oprot.writeMessageBegin("saveDiscounts", TMessageType.REPLY, seqid)
4631 
    result.write(oprot)
4632 
    oprot.writeMessageEnd()
4633 
    oprot.trans.flush()
4634 
 
690 chandransh 4635 
  def process_createOrders(self, seqid, iprot, oprot):
4636 
    args = createOrders_args()
559 chandransh 4637 
    args.read(iprot)
4638 
    iprot.readMessageEnd()
690 chandransh 4639 
    result = createOrders_result()
559 chandransh 4640 
    try:
11526 amit.gupta 4641 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime, args.firstSource, args.firstSourceTime, args.userId, args.schemeId, args.orderSource)
559 chandransh 4642 
    except ShoppingCartException, scx:
4643 
      result.scx = scx
690 chandransh 4644 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 4645 
    result.write(oprot)
4646 
    oprot.writeMessageEnd()
4647 
    oprot.trans.flush()
4648 
 
4649 
  def process_validateCart(self, seqid, iprot, oprot):
4650 
    args = validateCart_args()
4651 
    args.read(iprot)
4652 
    iprot.readMessageEnd()
4653 
    result = validateCart_result()
575 chandransh 4654 
    try:
3557 rajveer 4655 
      result.success = self._handler.validateCart(args.cartId, args.sourceId)
575 chandransh 4656 
    except ShoppingCartException, scex:
4657 
      result.scex = scex
559 chandransh 4658 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
4659 
    result.write(oprot)
4660 
    oprot.writeMessageEnd()
4661 
    oprot.trans.flush()
4662 
 
11980 amit.gupta 4663 
  def process_validateCartWithDealerCoupon(self, seqid, iprot, oprot):
4664 
    args = validateCartWithDealerCoupon_args()
4665 
    args.read(iprot)
4666 
    iprot.readMessageEnd()
4667 
    result = validateCartWithDealerCoupon_result()
4668 
    try:
4669 
      result.success = self._handler.validateCartWithDealerCoupon(args.cartId, args.sourceId, args.dealCoupon)
4670 
    except ShoppingCartException, scex:
4671 
      result.scex = scex
4672 
    oprot.writeMessageBegin("validateCartWithDealerCoupon", TMessageType.REPLY, seqid)
4673 
    result.write(oprot)
4674 
    oprot.writeMessageEnd()
4675 
    oprot.trans.flush()
4676 
 
690 chandransh 4677 
  def process_mergeCart(self, seqid, iprot, oprot):
4678 
    args = mergeCart_args()
575 chandransh 4679 
    args.read(iprot)
4680 
    iprot.readMessageEnd()
690 chandransh 4681 
    result = mergeCart_result()
4682 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
4683 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
4684 
    result.write(oprot)
4685 
    oprot.writeMessageEnd()
4686 
    oprot.trans.flush()
4687 
 
4688 
  def process_checkOut(self, seqid, iprot, oprot):
4689 
    args = checkOut_args()
4690 
    args.read(iprot)
4691 
    iprot.readMessageEnd()
4692 
    result = checkOut_result()
575 chandransh 4693 
    try:
690 chandransh 4694 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 4695 
    except ShoppingCartException, scex:
4696 
      result.scex = scex
690 chandransh 4697 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 4698 
    result.write(oprot)
4699 
    oprot.writeMessageEnd()
4700 
    oprot.trans.flush()
4701 
 
690 chandransh 4702 
  def process_resetCart(self, seqid, iprot, oprot):
4703 
    args = resetCart_args()
559 chandransh 4704 
    args.read(iprot)
4705 
    iprot.readMessageEnd()
690 chandransh 4706 
    result = resetCart_result()
4707 
    try:
4708 
      result.success = self._handler.resetCart(args.cartId, args.items)
4709 
    except ShoppingCartException, scex:
4710 
      result.scex = scex
4711 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 4712 
    result.write(oprot)
4713 
    oprot.writeMessageEnd()
4714 
    oprot.trans.flush()
4715 
 
2981 rajveer 4716 
  def process_getUserCount(self, seqid, iprot, oprot):
4717 
    args = getUserCount_args()
559 chandransh 4718 
    args.read(iprot)
4719 
    iprot.readMessageEnd()
2981 rajveer 4720 
    result = getUserCount_result()
4721 
    result.success = self._handler.getUserCount(args.userType)
4722 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 4723 
    result.write(oprot)
4724 
    oprot.writeMessageEnd()
4725 
    oprot.trans.flush()
4726 
 
2981 rajveer 4727 
  def process_getAllUsers(self, seqid, iprot, oprot):
4728 
    args = getAllUsers_args()
559 chandransh 4729 
    args.read(iprot)
4730 
    iprot.readMessageEnd()
2981 rajveer 4731 
    result = getAllUsers_result()
4732 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
4733 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 4734 
    result.write(oprot)
4735 
    oprot.writeMessageEnd()
4736 
    oprot.trans.flush()
4737 
 
2981 rajveer 4738 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
4739 
    args = getMyResearchItems_args()
559 chandransh 4740 
    args.read(iprot)
4741 
    iprot.readMessageEnd()
2981 rajveer 4742 
    result = getMyResearchItems_result()
559 chandransh 4743 
    try:
2981 rajveer 4744 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 4745 
    except WidgetException, scx:
4746 
      result.scx = scx
2981 rajveer 4747 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 4748 
    result.write(oprot)
4749 
    oprot.writeMessageEnd()
4750 
    oprot.trans.flush()
4751 
 
2981 rajveer 4752 
  def process_updateMyResearch(self, seqid, iprot, oprot):
4753 
    args = updateMyResearch_args()
772 rajveer 4754 
    args.read(iprot)
4755 
    iprot.readMessageEnd()
2981 rajveer 4756 
    result = updateMyResearch_result()
4757 
    try:
4758 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
4759 
    except WidgetException, scx:
4760 
      result.scx = scx
4761 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 4762 
    result.write(oprot)
4763 
    oprot.writeMessageEnd()
4764 
    oprot.trans.flush()
559 chandransh 4765 
 
2981 rajveer 4766 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
4767 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 4768 
    args.read(iprot)
4769 
    iprot.readMessageEnd()
2981 rajveer 4770 
    result = deleteItemFromMyResearch_result()
4771 
    try:
4772 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
4773 
    except WidgetException, scx:
4774 
      result.scx = scx
4775 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 4776 
    result.write(oprot)
4777 
    oprot.writeMessageEnd()
4778 
    oprot.trans.flush()
772 rajveer 4779 
 
2981 rajveer 4780 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
4781 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 4782 
    args.read(iprot)
4783 
    iprot.readMessageEnd()
2981 rajveer 4784 
    result = getBrowseHistoryItems_result()
4785 
    try:
4786 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
4787 
    except WidgetException, scx:
4788 
      result.scx = scx
4789 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 4790 
    result.write(oprot)
4791 
    oprot.writeMessageEnd()
4792 
    oprot.trans.flush()
1596 ankur.sing 4793 
 
2981 rajveer 4794 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
4795 
    args = updateBrowseHistory_args()
2642 varun.gupt 4796 
    args.read(iprot)
4797 
    iprot.readMessageEnd()
2981 rajveer 4798 
    result = updateBrowseHistory_result()
4799 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
4800 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 4801 
    result.write(oprot)
4802 
    oprot.writeMessageEnd()
4803 
    oprot.trans.flush()
1673 ankur.sing 4804 
 
3385 varun.gupt 4805 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
4806 
    args = getCartsWithCouponCount_args()
4807 
    args.read(iprot)
4808 
    iprot.readMessageEnd()
4809 
    result = getCartsWithCouponCount_result()
4810 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
4811 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
4812 
    result.write(oprot)
4813 
    oprot.writeMessageEnd()
4814 
    oprot.trans.flush()
2642 varun.gupt 4815 
 
3499 mandeep.dh 4816 
  def process_increaseTrustLevel(self, seqid, iprot, oprot):
4817 
    args = increaseTrustLevel_args()
4818 
    args.read(iprot)
4819 
    iprot.readMessageEnd()
4820 
    self._handler.increaseTrustLevel(args.userId, args.trustLevelDelta)
3530 mandeep.dh 4821 
    return
3385 varun.gupt 4822 
 
5407 amar.kumar 4823 
  def process_getTrustLevel(self, seqid, iprot, oprot):
4824 
    args = getTrustLevel_args()
4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4827 
    result = getTrustLevel_result()
4828 
    result.success = self._handler.getTrustLevel(args.userId)
4829 
    oprot.writeMessageBegin("getTrustLevel", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4833 
 
4668 varun.gupt 4834 
  def process_showCODOption(self, seqid, iprot, oprot):
4835 
    args = showCODOption_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = showCODOption_result()
4839 
    result.success = self._handler.showCODOption(args.cartId, args.sourceId, args.pincode)
4840 
    oprot.writeMessageBegin("showCODOption", TMessageType.REPLY, seqid)
4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
3499 mandeep.dh 4844 
 
5623 anupam.sin 4845 
  def process_getUserEmails(self, seqid, iprot, oprot):
4846 
    args = getUserEmails_args()
4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
4849 
    result = getUserEmails_result()
4850 
    result.success = self._handler.getUserEmails(args.startDate, args.endDate)
4851 
    oprot.writeMessageBegin("getUserEmails", TMessageType.REPLY, seqid)
4852 
    result.write(oprot)
4853 
    oprot.writeMessageEnd()
4854 
    oprot.trans.flush()
4668 varun.gupt 4855 
 
6903 anupam.sin 4856 
  def process_insureItem(self, seqid, iprot, oprot):
4857 
    args = insureItem_args()
4858 
    args.read(iprot)
4859 
    iprot.readMessageEnd()
4860 
    result = insureItem_result()
9299 kshitij.so 4861 
    result.success = self._handler.insureItem(args.itemId, args.cartId, args.toInsure, args.insurerType)
6903 anupam.sin 4862 
    oprot.writeMessageBegin("insureItem", TMessageType.REPLY, seqid)
4863 
    result.write(oprot)
4864 
    oprot.writeMessageEnd()
4865 
    oprot.trans.flush()
4866 
 
4867 
  def process_cancelInsurance(self, seqid, iprot, oprot):
4868 
    args = cancelInsurance_args()
4869 
    args.read(iprot)
4870 
    iprot.readMessageEnd()
4871 
    result = cancelInsurance_result()
4872 
    result.success = self._handler.cancelInsurance(args.cartId)
4873 
    oprot.writeMessageBegin("cancelInsurance", TMessageType.REPLY, seqid)
4874 
    result.write(oprot)
4875 
    oprot.writeMessageEnd()
4876 
    oprot.trans.flush()
4877 
 
4878 
  def process_storeInsuranceSpecificDetails(self, seqid, iprot, oprot):
4879 
    args = storeInsuranceSpecificDetails_args()
4880 
    args.read(iprot)
4881 
    iprot.readMessageEnd()
4882 
    result = storeInsuranceSpecificDetails_result()
4883 
    result.success = self._handler.storeInsuranceSpecificDetails(args.addressId, args.dob, args.guardianName)
4884 
    oprot.writeMessageBegin("storeInsuranceSpecificDetails", TMessageType.REPLY, seqid)
4885 
    result.write(oprot)
4886 
    oprot.writeMessageEnd()
4887 
    oprot.trans.flush()
4888 
 
4889 
  def process_isInsuranceDetailPresent(self, seqid, iprot, oprot):
4890 
    args = isInsuranceDetailPresent_args()
4891 
    args.read(iprot)
4892 
    iprot.readMessageEnd()
4893 
    result = isInsuranceDetailPresent_result()
4894 
    result.success = self._handler.isInsuranceDetailPresent(args.addressId)
4895 
    oprot.writeMessageBegin("isInsuranceDetailPresent", TMessageType.REPLY, seqid)
4896 
    result.write(oprot)
4897 
    oprot.writeMessageEnd()
4898 
    oprot.trans.flush()
4899 
 
9791 rajveer 4900 
  def process_getProductsAddedToCart(self, seqid, iprot, oprot):
4901 
    args = getProductsAddedToCart_args()
6821 amar.kumar 4902 
    args.read(iprot)
4903 
    iprot.readMessageEnd()
9791 rajveer 4904 
    result = getProductsAddedToCart_result()
4905 
    result.success = self._handler.getProductsAddedToCart(args.startDate, args.endDate)
4906 
    oprot.writeMessageBegin("getProductsAddedToCart", TMessageType.REPLY, seqid)
6821 amar.kumar 4907 
    result.write(oprot)
4908 
    oprot.writeMessageEnd()
4909 
    oprot.trans.flush()
5623 anupam.sin 4910 
 
11592 amit.gupta 4911 
  def process_validateCartPlus(self, seqid, iprot, oprot):
4912 
    args = validateCartPlus_args()
4913 
    args.read(iprot)
4914 
    iprot.readMessageEnd()
4915 
    result = validateCartPlus_result()
4916 
    try:
11980 amit.gupta 4917 
      result.success = self._handler.validateCartPlus(args.cartId, args.sourceId, args.dealerCoupon)
11592 amit.gupta 4918 
    except ShoppingCartException, scex:
4919 
      result.scex = scex
4920 
    oprot.writeMessageBegin("validateCartPlus", TMessageType.REPLY, seqid)
4921 
    result.write(oprot)
4922 
    oprot.writeMessageEnd()
4923 
    oprot.trans.flush()
6821 amar.kumar 4924 
 
11679 vikram.rag 4925 
  def process_isPrivateDealUser(self, seqid, iprot, oprot):
4926 
    args = isPrivateDealUser_args()
4927 
    args.read(iprot)
4928 
    iprot.readMessageEnd()
4929 
    result = isPrivateDealUser_result()
4930 
    result.success = self._handler.isPrivateDealUser(args.userId)
4931 
    oprot.writeMessageBegin("isPrivateDealUser", TMessageType.REPLY, seqid)
4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
11592 amit.gupta 4935 
 
11890 kshitij.so 4936 
  def process_addPrivateDealUser(self, seqid, iprot, oprot):
4937 
    args = addPrivateDealUser_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    result = addPrivateDealUser_result()
4941 
    result.success = self._handler.addPrivateDealUser(args.userId)
4942 
    oprot.writeMessageBegin("addPrivateDealUser", TMessageType.REPLY, seqid)
4943 
    result.write(oprot)
4944 
    oprot.writeMessageEnd()
4945 
    oprot.trans.flush()
11679 vikram.rag 4946 
 
11890 kshitij.so 4947 
  def process_changePrivateDealUserStatus(self, seqid, iprot, oprot):
4948 
    args = changePrivateDealUserStatus_args()
4949 
    args.read(iprot)
4950 
    iprot.readMessageEnd()
4951 
    result = changePrivateDealUserStatus_result()
4952 
    result.success = self._handler.changePrivateDealUserStatus(args.userId, args.isActive)
4953 
    oprot.writeMessageBegin("changePrivateDealUserStatus", TMessageType.REPLY, seqid)
4954 
    result.write(oprot)
4955 
    oprot.writeMessageEnd()
4956 
    oprot.trans.flush()
4957 
 
4958 
  def process_getPrivateDealUser(self, seqid, iprot, oprot):
4959 
    args = getPrivateDealUser_args()
4960 
    args.read(iprot)
4961 
    iprot.readMessageEnd()
4962 
    result = getPrivateDealUser_result()
4963 
    result.success = self._handler.getPrivateDealUser(args.userId)
4964 
    oprot.writeMessageBegin("getPrivateDealUser", TMessageType.REPLY, seqid)
4965 
    result.write(oprot)
4966 
    oprot.writeMessageEnd()
4967 
    oprot.trans.flush()
4968 
 
12696 amit.gupta 4969 
  def process_registerCounter(self, seqid, iprot, oprot):
4970 
    args = registerCounter_args()
4971 
    args.read(iprot)
4972 
    iprot.readMessageEnd()
4973 
    result = registerCounter_result()
4974 
    result.success = self._handler.registerCounter(args.counter, args.userId)
4975 
    oprot.writeMessageBegin("registerCounter", TMessageType.REPLY, seqid)
4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
11890 kshitij.so 4979 
 
12722 amit.gupta 4980 
  def process_searchCounter(self, seqid, iprot, oprot):
4981 
    args = searchCounter_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = searchCounter_result()
4985 
    result.success = self._handler.searchCounter(args.type1, args.searchString)
4986 
    oprot.writeMessageBegin("searchCounter", TMessageType.REPLY, seqid)
4987 
    result.write(oprot)
4988 
    oprot.writeMessageEnd()
4989 
    oprot.trans.flush()
12696 amit.gupta 4990 
 
18977 amit.gupta 4991 
  def process_getCounterByUserId(self, seqid, iprot, oprot):
4992 
    args = getCounterByUserId_args()
4993 
    args.read(iprot)
4994 
    iprot.readMessageEnd()
4995 
    result = getCounterByUserId_result()
4996 
    result.success = self._handler.getCounterByUserId(args.userId)
4997 
    oprot.writeMessageBegin("getCounterByUserId", TMessageType.REPLY, seqid)
4998 
    result.write(oprot)
4999 
    oprot.writeMessageEnd()
5000 
    oprot.trans.flush()
5001 
 
12722 amit.gupta 5002 
  def process_getAllUsersByCounter(self, seqid, iprot, oprot):
5003 
    args = getAllUsersByCounter_args()
5004 
    args.read(iprot)
5005 
    iprot.readMessageEnd()
5006 
    result = getAllUsersByCounter_result()
5007 
    result.success = self._handler.getAllUsersByCounter(args.counterId)
5008 
    oprot.writeMessageBegin("getAllUsersByCounter", TMessageType.REPLY, seqid)
5009 
    result.write(oprot)
5010 
    oprot.writeMessageEnd()
5011 
    oprot.trans.flush()
5012 
 
15251 manish.sha 5013 
  def process_getActiveAccessTokenForUser(self, seqid, iprot, oprot):
5014 
    args = getActiveAccessTokenForUser_args()
5015 
    args.read(iprot)
5016 
    iprot.readMessageEnd()
5017 
    result = getActiveAccessTokenForUser_result()
5018 
    result.success = self._handler.getActiveAccessTokenForUser(args.userId, args.source)
5019 
    oprot.writeMessageBegin("getActiveAccessTokenForUser", TMessageType.REPLY, seqid)
5020 
    result.write(oprot)
5021 
    oprot.writeMessageEnd()
5022 
    oprot.trans.flush()
12722 amit.gupta 5023 
 
15251 manish.sha 5024 
  def process_validateAccessToken(self, seqid, iprot, oprot):
5025 
    args = validateAccessToken_args()
5026 
    args.read(iprot)
5027 
    iprot.readMessageEnd()
5028 
    result = validateAccessToken_result()
5029 
    result.success = self._handler.validateAccessToken(args.accessToken)
5030 
    oprot.writeMessageBegin("validateAccessToken", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
17782 amit.gupta 5035 
  def process_addItemsToCart(self, seqid, iprot, oprot):
5036 
    args = addItemsToCart_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = addItemsToCart_result()
5040 
    result.success = self._handler.addItemsToCart(args.cartId, args.itemQty, args.couponCode)
5041 
    oprot.writeMessageBegin("addItemsToCart", TMessageType.REPLY, seqid)
5042 
    result.write(oprot)
5043 
    oprot.writeMessageEnd()
5044 
    oprot.trans.flush()
15251 manish.sha 5045 
 
17782 amit.gupta 5046 
  def process_validateCartNew(self, seqid, iprot, oprot):
5047 
    args = validateCartNew_args()
5048 
    args.read(iprot)
5049 
    iprot.readMessageEnd()
5050 
    result = validateCartNew_result()
5051 
    result.success = self._handler.validateCartNew(args.cartId, args.pinCode, args.sourceId)
5052 
    oprot.writeMessageBegin("validateCartNew", TMessageType.REPLY, seqid)
5053 
    result.write(oprot)
5054 
    oprot.writeMessageEnd()
5055 
    oprot.trans.flush()
5056 
 
18644 manish.sha 5057 
  def process_isAddressEditableForCounter(self, seqid, iprot, oprot):
5058 
    args = isAddressEditableForCounter_args()
18530 manish.sha 5059 
    args.read(iprot)
5060 
    iprot.readMessageEnd()
18644 manish.sha 5061 
    result = isAddressEditableForCounter_result()
5062 
    result.success = self._handler.isAddressEditableForCounter(args.userId)
5063 
    oprot.writeMessageBegin("isAddressEditableForCounter", TMessageType.REPLY, seqid)
18530 manish.sha 5064 
    result.write(oprot)
5065 
    oprot.writeMessageEnd()
5066 
    oprot.trans.flush()
17782 amit.gupta 5067 
 
18530 manish.sha 5068 
  def process_getBillingAddressForUser(self, seqid, iprot, oprot):
5069 
    args = getBillingAddressForUser_args()
5070 
    args.read(iprot)
5071 
    iprot.readMessageEnd()
5072 
    result = getBillingAddressForUser_result()
5073 
    result.success = self._handler.getBillingAddressForUser(args.userId)
5074 
    oprot.writeMessageBegin("getBillingAddressForUser", TMessageType.REPLY, seqid)
5075 
    result.write(oprot)
5076 
    oprot.writeMessageEnd()
5077 
    oprot.trans.flush()
5078 
 
18590 manish.sha 5079 
  def process_isCreditorAssigned(self, seqid, iprot, oprot):
5080 
    args = isCreditorAssigned_args()
5081 
    args.read(iprot)
5082 
    iprot.readMessageEnd()
5083 
    result = isCreditorAssigned_result()
5084 
    result.success = self._handler.isCreditorAssigned(args.userId)
5085 
    oprot.writeMessageBegin("isCreditorAssigned", TMessageType.REPLY, seqid)
5086 
    result.write(oprot)
5087 
    oprot.writeMessageEnd()
5088 
    oprot.trans.flush()
18530 manish.sha 5089 
 
18735 manish.sha 5090 
  def process_isTaxInvoiceEnabledUser(self, seqid, iprot, oprot):
5091 
    args = isTaxInvoiceEnabledUser_args()
5092 
    args.read(iprot)
5093 
    iprot.readMessageEnd()
5094 
    result = isTaxInvoiceEnabledUser_result()
5095 
    result.success = self._handler.isTaxInvoiceEnabledUser(args.userId)
5096 
    oprot.writeMessageBegin("isTaxInvoiceEnabledUser", TMessageType.REPLY, seqid)
5097 
    result.write(oprot)
5098 
    oprot.writeMessageEnd()
5099 
    oprot.trans.flush()
18590 manish.sha 5100 
 
18764 kshitij.so 5101 
  def process_getCartByValue(self, seqid, iprot, oprot):
5102 
    args = getCartByValue_args()
5103 
    args.read(iprot)
5104 
    iprot.readMessageEnd()
5105 
    result = getCartByValue_result()
5106 
    result.success = self._handler.getCartByValue(args.cartIds)
5107 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
5108 
    result.write(oprot)
5109 
    oprot.writeMessageEnd()
5110 
    oprot.trans.flush()
18735 manish.sha 5111 
 
18764 kshitij.so 5112 
 
94 ashish 5113 
# HELPER FUNCTIONS AND STRUCTURES
5114 
 
559 chandransh 5115 
class createAnonymousUser_args:
94 ashish 5116 
  """
5117 
  Attributes:
559 chandransh 5118 
   - jsessionId
94 ashish 5119 
  """
5120 
 
5121 
  thrift_spec = (
5122 
    None, # 0
559 chandransh 5123 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 5124 
  )
5125 
 
559 chandransh 5126 
  def __init__(self, jsessionId=None,):
5127 
    self.jsessionId = jsessionId
94 ashish 5128 
 
5129 
  def read(self, iprot):
5130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5132 
      return
5133 
    iprot.readStructBegin()
5134 
    while True:
5135 
      (fname, ftype, fid) = iprot.readFieldBegin()
5136 
      if ftype == TType.STOP:
5137 
        break
5138 
      if fid == 1:
559 chandransh 5139 
        if ftype == TType.STRING:
5140 
          self.jsessionId = iprot.readString();
94 ashish 5141 
        else:
5142 
          iprot.skip(ftype)
5143 
      else:
5144 
        iprot.skip(ftype)
5145 
      iprot.readFieldEnd()
5146 
    iprot.readStructEnd()
5147 
 
5148 
  def write(self, oprot):
5149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5151 
      return
559 chandransh 5152 
    oprot.writeStructBegin('createAnonymousUser_args')
3431 rajveer 5153 
    if self.jsessionId is not None:
559 chandransh 5154 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
5155 
      oprot.writeString(self.jsessionId)
94 ashish 5156 
      oprot.writeFieldEnd()
5157 
    oprot.writeFieldStop()
5158 
    oprot.writeStructEnd()
5159 
 
3431 rajveer 5160 
  def validate(self):
5161 
    return
5162 
 
5163 
 
94 ashish 5164 
  def __repr__(self):
5165 
    L = ['%s=%r' % (key, value)
5166 
      for key, value in self.__dict__.iteritems()]
5167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5168 
 
5169 
  def __eq__(self, other):
5170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5171 
 
5172 
  def __ne__(self, other):
5173 
    return not (self == other)
5174 
 
559 chandransh 5175 
class createAnonymousUser_result:
94 ashish 5176 
  """
5177 
  Attributes:
5178 
   - success
559 chandransh 5179 
   - ucex
94 ashish 5180 
  """
5181 
 
5182 
  thrift_spec = (
559 chandransh 5183 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5184 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5185 
  )
5186 
 
559 chandransh 5187 
  def __init__(self, success=None, ucex=None,):
94 ashish 5188 
    self.success = success
559 chandransh 5189 
    self.ucex = ucex
94 ashish 5190 
 
5191 
  def read(self, iprot):
5192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5194 
      return
5195 
    iprot.readStructBegin()
5196 
    while True:
5197 
      (fname, ftype, fid) = iprot.readFieldBegin()
5198 
      if ftype == TType.STOP:
5199 
        break
5200 
      if fid == 0:
5201 
        if ftype == TType.STRUCT:
559 chandransh 5202 
          self.success = User()
94 ashish 5203 
          self.success.read(iprot)
5204 
        else:
5205 
          iprot.skip(ftype)
5206 
      elif fid == 1:
5207 
        if ftype == TType.STRUCT:
559 chandransh 5208 
          self.ucex = UserContextException()
5209 
          self.ucex.read(iprot)
94 ashish 5210 
        else:
5211 
          iprot.skip(ftype)
5212 
      else:
5213 
        iprot.skip(ftype)
5214 
      iprot.readFieldEnd()
5215 
    iprot.readStructEnd()
5216 
 
5217 
  def write(self, oprot):
5218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5220 
      return
559 chandransh 5221 
    oprot.writeStructBegin('createAnonymousUser_result')
3431 rajveer 5222 
    if self.success is not None:
94 ashish 5223 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5224 
      self.success.write(oprot)
5225 
      oprot.writeFieldEnd()
3431 rajveer 5226 
    if self.ucex is not None:
559 chandransh 5227 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5228 
      self.ucex.write(oprot)
94 ashish 5229 
      oprot.writeFieldEnd()
5230 
    oprot.writeFieldStop()
5231 
    oprot.writeStructEnd()
5232 
 
3431 rajveer 5233 
  def validate(self):
5234 
    return
5235 
 
5236 
 
94 ashish 5237 
  def __repr__(self):
5238 
    L = ['%s=%r' % (key, value)
5239 
      for key, value in self.__dict__.iteritems()]
5240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5241 
 
5242 
  def __eq__(self, other):
5243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5244 
 
5245 
  def __ne__(self, other):
5246 
    return not (self == other)
5247 
 
559 chandransh 5248 
class getUserById_args:
94 ashish 5249 
  """
5250 
  Attributes:
5251 
   - userId
5252 
  """
5253 
 
5254 
  thrift_spec = (
5255 
    None, # 0
5256 
    (1, TType.I64, 'userId', None, None, ), # 1
5257 
  )
5258 
 
559 chandransh 5259 
  def __init__(self, userId=None,):
94 ashish 5260 
    self.userId = userId
5261 
 
5262 
  def read(self, iprot):
5263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5265 
      return
5266 
    iprot.readStructBegin()
5267 
    while True:
5268 
      (fname, ftype, fid) = iprot.readFieldBegin()
5269 
      if ftype == TType.STOP:
5270 
        break
5271 
      if fid == 1:
5272 
        if ftype == TType.I64:
5273 
          self.userId = iprot.readI64();
5274 
        else:
5275 
          iprot.skip(ftype)
5276 
      else:
5277 
        iprot.skip(ftype)
5278 
      iprot.readFieldEnd()
5279 
    iprot.readStructEnd()
5280 
 
5281 
  def write(self, oprot):
5282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5284 
      return
559 chandransh 5285 
    oprot.writeStructBegin('getUserById_args')
3431 rajveer 5286 
    if self.userId is not None:
94 ashish 5287 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5288 
      oprot.writeI64(self.userId)
5289 
      oprot.writeFieldEnd()
5290 
    oprot.writeFieldStop()
5291 
    oprot.writeStructEnd()
5292 
 
3431 rajveer 5293 
  def validate(self):
5294 
    return
5295 
 
5296 
 
94 ashish 5297 
  def __repr__(self):
5298 
    L = ['%s=%r' % (key, value)
5299 
      for key, value in self.__dict__.iteritems()]
5300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5301 
 
5302 
  def __eq__(self, other):
5303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5304 
 
5305 
  def __ne__(self, other):
5306 
    return not (self == other)
5307 
 
559 chandransh 5308 
class getUserById_result:
94 ashish 5309 
  """
5310 
  Attributes:
5311 
   - success
559 chandransh 5312 
   - ucex
94 ashish 5313 
  """
5314 
 
5315 
  thrift_spec = (
559 chandransh 5316 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5317 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5318 
  )
5319 
 
559 chandransh 5320 
  def __init__(self, success=None, ucex=None,):
94 ashish 5321 
    self.success = success
559 chandransh 5322 
    self.ucex = ucex
94 ashish 5323 
 
5324 
  def read(self, iprot):
5325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5327 
      return
5328 
    iprot.readStructBegin()
5329 
    while True:
5330 
      (fname, ftype, fid) = iprot.readFieldBegin()
5331 
      if ftype == TType.STOP:
5332 
        break
5333 
      if fid == 0:
5334 
        if ftype == TType.STRUCT:
559 chandransh 5335 
          self.success = User()
94 ashish 5336 
          self.success.read(iprot)
5337 
        else:
5338 
          iprot.skip(ftype)
5339 
      elif fid == 1:
5340 
        if ftype == TType.STRUCT:
559 chandransh 5341 
          self.ucex = UserContextException()
5342 
          self.ucex.read(iprot)
94 ashish 5343 
        else:
5344 
          iprot.skip(ftype)
5345 
      else:
5346 
        iprot.skip(ftype)
5347 
      iprot.readFieldEnd()
5348 
    iprot.readStructEnd()
5349 
 
5350 
  def write(self, oprot):
5351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5353 
      return
559 chandransh 5354 
    oprot.writeStructBegin('getUserById_result')
3431 rajveer 5355 
    if self.success is not None:
94 ashish 5356 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5357 
      self.success.write(oprot)
5358 
      oprot.writeFieldEnd()
3431 rajveer 5359 
    if self.ucex is not None:
559 chandransh 5360 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5361 
      self.ucex.write(oprot)
94 ashish 5362 
      oprot.writeFieldEnd()
5363 
    oprot.writeFieldStop()
5364 
    oprot.writeStructEnd()
5365 
 
3431 rajveer 5366 
  def validate(self):
5367 
    return
5368 
 
5369 
 
94 ashish 5370 
  def __repr__(self):
5371 
    L = ['%s=%r' % (key, value)
5372 
      for key, value in self.__dict__.iteritems()]
5373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5374 
 
5375 
  def __eq__(self, other):
5376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5377 
 
5378 
  def __ne__(self, other):
5379 
    return not (self == other)
5380 
 
5326 rajveer 5381 
class getUserByCartId_args:
1491 vikas 5382 
  """
5383 
  Attributes:
5326 rajveer 5384 
   - cartId
1491 vikas 5385 
  """
5386 
 
5387 
  thrift_spec = (
5388 
    None, # 0
5326 rajveer 5389 
    (1, TType.I64, 'cartId', None, None, ), # 1
1491 vikas 5390 
  )
5391 
 
5326 rajveer 5392 
  def __init__(self, cartId=None,):
5393 
    self.cartId = cartId
1491 vikas 5394 
 
5395 
  def read(self, iprot):
5396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5398 
      return
5399 
    iprot.readStructBegin()
5400 
    while True:
5401 
      (fname, ftype, fid) = iprot.readFieldBegin()
5402 
      if ftype == TType.STOP:
5403 
        break
5404 
      if fid == 1:
5326 rajveer 5405 
        if ftype == TType.I64:
5406 
          self.cartId = iprot.readI64();
1491 vikas 5407 
        else:
5408 
          iprot.skip(ftype)
5409 
      else:
5410 
        iprot.skip(ftype)
5411 
      iprot.readFieldEnd()
5412 
    iprot.readStructEnd()
5413 
 
5414 
  def write(self, oprot):
5415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5417 
      return
5326 rajveer 5418 
    oprot.writeStructBegin('getUserByCartId_args')
5419 
    if self.cartId is not None:
5420 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5421 
      oprot.writeI64(self.cartId)
1491 vikas 5422 
      oprot.writeFieldEnd()
5423 
    oprot.writeFieldStop()
5424 
    oprot.writeStructEnd()
5425 
 
3431 rajveer 5426 
  def validate(self):
5427 
    return
5428 
 
5429 
 
1491 vikas 5430 
  def __repr__(self):
5431 
    L = ['%s=%r' % (key, value)
5432 
      for key, value in self.__dict__.iteritems()]
5433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5434 
 
5435 
  def __eq__(self, other):
5436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5437 
 
5438 
  def __ne__(self, other):
5439 
    return not (self == other)
5440 
 
5326 rajveer 5441 
class getUserByCartId_result:
1491 vikas 5442 
  """
5443 
  Attributes:
5444 
   - success
5445 
   - ucex
5446 
  """
5447 
 
5448 
  thrift_spec = (
5449 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5450 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5451 
  )
5452 
 
5453 
  def __init__(self, success=None, ucex=None,):
5454 
    self.success = success
5455 
    self.ucex = ucex
5456 
 
5457 
  def read(self, iprot):
5458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5460 
      return
5461 
    iprot.readStructBegin()
5462 
    while True:
5463 
      (fname, ftype, fid) = iprot.readFieldBegin()
5464 
      if ftype == TType.STOP:
5465 
        break
5466 
      if fid == 0:
5467 
        if ftype == TType.STRUCT:
5468 
          self.success = User()
5469 
          self.success.read(iprot)
5470 
        else:
5471 
          iprot.skip(ftype)
5472 
      elif fid == 1:
5473 
        if ftype == TType.STRUCT:
5474 
          self.ucex = UserContextException()
5475 
          self.ucex.read(iprot)
5476 
        else:
5477 
          iprot.skip(ftype)
5478 
      else:
5479 
        iprot.skip(ftype)
5480 
      iprot.readFieldEnd()
5481 
    iprot.readStructEnd()
5482 
 
5483 
  def write(self, oprot):
5484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5486 
      return
5326 rajveer 5487 
    oprot.writeStructBegin('getUserByCartId_result')
3431 rajveer 5488 
    if self.success is not None:
1491 vikas 5489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5490 
      self.success.write(oprot)
5491 
      oprot.writeFieldEnd()
3431 rajveer 5492 
    if self.ucex is not None:
1491 vikas 5493 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5494 
      self.ucex.write(oprot)
5495 
      oprot.writeFieldEnd()
5496 
    oprot.writeFieldStop()
5497 
    oprot.writeStructEnd()
5498 
 
3431 rajveer 5499 
  def validate(self):
5500 
    return
5501 
 
5502 
 
1491 vikas 5503 
  def __repr__(self):
5504 
    L = ['%s=%r' % (key, value)
5505 
      for key, value in self.__dict__.iteritems()]
5506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5507 
 
5508 
  def __eq__(self, other):
5509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5510 
 
5511 
  def __ne__(self, other):
5512 
    return not (self == other)
5513 
 
5326 rajveer 5514 
class getUserByEmail_args:
3032 mandeep.dh 5515 
  """
5516 
  Attributes:
5326 rajveer 5517 
   - email
3032 mandeep.dh 5518 
  """
5519 
 
5520 
  thrift_spec = (
5521 
    None, # 0
5326 rajveer 5522 
    (1, TType.STRING, 'email', None, None, ), # 1
3032 mandeep.dh 5523 
  )
5524 
 
5326 rajveer 5525 
  def __init__(self, email=None,):
5526 
    self.email = email
3032 mandeep.dh 5527 
 
5528 
  def read(self, iprot):
5529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5531 
      return
5532 
    iprot.readStructBegin()
5533 
    while True:
5534 
      (fname, ftype, fid) = iprot.readFieldBegin()
5535 
      if ftype == TType.STOP:
5536 
        break
5537 
      if fid == 1:
5326 rajveer 5538 
        if ftype == TType.STRING:
5539 
          self.email = iprot.readString();
3032 mandeep.dh 5540 
        else:
5541 
          iprot.skip(ftype)
5542 
      else:
5543 
        iprot.skip(ftype)
5544 
      iprot.readFieldEnd()
5545 
    iprot.readStructEnd()
5546 
 
5547 
  def write(self, oprot):
5548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5550 
      return
5326 rajveer 5551 
    oprot.writeStructBegin('getUserByEmail_args')
5552 
    if self.email is not None:
5553 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5554 
      oprot.writeString(self.email)
3032 mandeep.dh 5555 
      oprot.writeFieldEnd()
5556 
    oprot.writeFieldStop()
5557 
    oprot.writeStructEnd()
5558 
 
3431 rajveer 5559 
  def validate(self):
5560 
    return
5561 
 
5562 
 
3032 mandeep.dh 5563 
  def __repr__(self):
5564 
    L = ['%s=%r' % (key, value)
5565 
      for key, value in self.__dict__.iteritems()]
5566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5567 
 
5568 
  def __eq__(self, other):
5569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5570 
 
5571 
  def __ne__(self, other):
5572 
    return not (self == other)
5573 
 
5326 rajveer 5574 
class getUserByEmail_result:
3032 mandeep.dh 5575 
  """
5576 
  Attributes:
5577 
   - success
5578 
   - ucex
5579 
  """
5580 
 
5581 
  thrift_spec = (
5582 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5583 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5584 
  )
5585 
 
5586 
  def __init__(self, success=None, ucex=None,):
5587 
    self.success = success
5588 
    self.ucex = ucex
5589 
 
5590 
  def read(self, iprot):
5591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5593 
      return
5594 
    iprot.readStructBegin()
5595 
    while True:
5596 
      (fname, ftype, fid) = iprot.readFieldBegin()
5597 
      if ftype == TType.STOP:
5598 
        break
5599 
      if fid == 0:
5600 
        if ftype == TType.STRUCT:
5601 
          self.success = User()
5602 
          self.success.read(iprot)
5603 
        else:
5604 
          iprot.skip(ftype)
5605 
      elif fid == 1:
5606 
        if ftype == TType.STRUCT:
5607 
          self.ucex = UserContextException()
5608 
          self.ucex.read(iprot)
5609 
        else:
5610 
          iprot.skip(ftype)
5611 
      else:
5612 
        iprot.skip(ftype)
5613 
      iprot.readFieldEnd()
5614 
    iprot.readStructEnd()
5615 
 
5616 
  def write(self, oprot):
5617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5619 
      return
5326 rajveer 5620 
    oprot.writeStructBegin('getUserByEmail_result')
3431 rajveer 5621 
    if self.success is not None:
3032 mandeep.dh 5622 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5623 
      self.success.write(oprot)
5624 
      oprot.writeFieldEnd()
3431 rajveer 5625 
    if self.ucex is not None:
3032 mandeep.dh 5626 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5627 
      self.ucex.write(oprot)
5628 
      oprot.writeFieldEnd()
5629 
    oprot.writeFieldStop()
5630 
    oprot.writeStructEnd()
5631 
 
3431 rajveer 5632 
  def validate(self):
5633 
    return
5634 
 
5635 
 
3032 mandeep.dh 5636 
  def __repr__(self):
5637 
    L = ['%s=%r' % (key, value)
5638 
      for key, value in self.__dict__.iteritems()]
5639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5640 
 
5641 
  def __eq__(self, other):
5642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5643 
 
5644 
  def __ne__(self, other):
5645 
    return not (self == other)
5646 
 
5326 rajveer 5647 
class getUserByMobileNumber_args:
94 ashish 5648 
  """
5649 
  Attributes:
5326 rajveer 5650 
   - mobileNumber
94 ashish 5651 
  """
5652 
 
5653 
  thrift_spec = (
5654 
    None, # 0
5326 rajveer 5655 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
94 ashish 5656 
  )
5657 
 
5326 rajveer 5658 
  def __init__(self, mobileNumber=None,):
5659 
    self.mobileNumber = mobileNumber
94 ashish 5660 
 
5661 
  def read(self, iprot):
5662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5664 
      return
5665 
    iprot.readStructBegin()
5666 
    while True:
5667 
      (fname, ftype, fid) = iprot.readFieldBegin()
5668 
      if ftype == TType.STOP:
5669 
        break
5670 
      if fid == 1:
5326 rajveer 5671 
        if ftype == TType.I64:
5672 
          self.mobileNumber = iprot.readI64();
94 ashish 5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      else:
5676 
        iprot.skip(ftype)
5677 
      iprot.readFieldEnd()
5678 
    iprot.readStructEnd()
5679 
 
5680 
  def write(self, oprot):
5681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5683 
      return
5326 rajveer 5684 
    oprot.writeStructBegin('getUserByMobileNumber_args')
5685 
    if self.mobileNumber is not None:
5686 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
5687 
      oprot.writeI64(self.mobileNumber)
94 ashish 5688 
      oprot.writeFieldEnd()
5689 
    oprot.writeFieldStop()
5690 
    oprot.writeStructEnd()
5691 
 
3431 rajveer 5692 
  def validate(self):
5693 
    return
5694 
 
5695 
 
94 ashish 5696 
  def __repr__(self):
5697 
    L = ['%s=%r' % (key, value)
5698 
      for key, value in self.__dict__.iteritems()]
5699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5700 
 
5701 
  def __eq__(self, other):
5702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5703 
 
5704 
  def __ne__(self, other):
5705 
    return not (self == other)
5706 
 
5326 rajveer 5707 
class getUserByMobileNumber_result:
94 ashish 5708 
  """
5709 
  Attributes:
5710 
   - success
559 chandransh 5711 
   - ucex
94 ashish 5712 
  """
5713 
 
5714 
  thrift_spec = (
559 chandransh 5715 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5716 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5717 
  )
5718 
 
559 chandransh 5719 
  def __init__(self, success=None, ucex=None,):
94 ashish 5720 
    self.success = success
559 chandransh 5721 
    self.ucex = ucex
94 ashish 5722 
 
5723 
  def read(self, iprot):
5724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5726 
      return
5727 
    iprot.readStructBegin()
5728 
    while True:
5729 
      (fname, ftype, fid) = iprot.readFieldBegin()
5730 
      if ftype == TType.STOP:
5731 
        break
5732 
      if fid == 0:
5733 
        if ftype == TType.STRUCT:
559 chandransh 5734 
          self.success = User()
94 ashish 5735 
          self.success.read(iprot)
5736 
        else:
5737 
          iprot.skip(ftype)
5738 
      elif fid == 1:
5739 
        if ftype == TType.STRUCT:
559 chandransh 5740 
          self.ucex = UserContextException()
5741 
          self.ucex.read(iprot)
94 ashish 5742 
        else:
5743 
          iprot.skip(ftype)
5744 
      else:
5745 
        iprot.skip(ftype)
5746 
      iprot.readFieldEnd()
5747 
    iprot.readStructEnd()
5748 
 
5749 
  def write(self, oprot):
5750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5752 
      return
5326 rajveer 5753 
    oprot.writeStructBegin('getUserByMobileNumber_result')
3431 rajveer 5754 
    if self.success is not None:
94 ashish 5755 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5756 
      self.success.write(oprot)
5757 
      oprot.writeFieldEnd()
3431 rajveer 5758 
    if self.ucex is not None:
559 chandransh 5759 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5760 
      self.ucex.write(oprot)
94 ashish 5761 
      oprot.writeFieldEnd()
5762 
    oprot.writeFieldStop()
5763 
    oprot.writeStructEnd()
5764 
 
3431 rajveer 5765 
  def validate(self):
5766 
    return
5767 
 
5768 
 
94 ashish 5769 
  def __repr__(self):
5770 
    L = ['%s=%r' % (key, value)
5771 
      for key, value in self.__dict__.iteritems()]
5772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5773 
 
5774 
  def __eq__(self, other):
5775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5776 
 
5777 
  def __ne__(self, other):
5778 
    return not (self == other)
5779 
 
5326 rajveer 5780 
class createUser_args:
94 ashish 5781 
  """
5782 
  Attributes:
559 chandransh 5783 
   - user
94 ashish 5784 
  """
5785 
 
5786 
  thrift_spec = (
5787 
    None, # 0
559 chandransh 5788 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5789 
  )
5790 
 
559 chandransh 5791 
  def __init__(self, user=None,):
5792 
    self.user = user
94 ashish 5793 
 
5794 
  def read(self, iprot):
5795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5797 
      return
5798 
    iprot.readStructBegin()
5799 
    while True:
5800 
      (fname, ftype, fid) = iprot.readFieldBegin()
5801 
      if ftype == TType.STOP:
5802 
        break
5803 
      if fid == 1:
559 chandransh 5804 
        if ftype == TType.STRUCT:
5805 
          self.user = User()
5806 
          self.user.read(iprot)
94 ashish 5807 
        else:
5808 
          iprot.skip(ftype)
5809 
      else:
5810 
        iprot.skip(ftype)
5811 
      iprot.readFieldEnd()
5812 
    iprot.readStructEnd()
5813 
 
5814 
  def write(self, oprot):
5815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5817 
      return
5326 rajveer 5818 
    oprot.writeStructBegin('createUser_args')
3431 rajveer 5819 
    if self.user is not None:
559 chandransh 5820 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5821 
      self.user.write(oprot)
94 ashish 5822 
      oprot.writeFieldEnd()
5823 
    oprot.writeFieldStop()
5824 
    oprot.writeStructEnd()
5825 
 
3431 rajveer 5826 
  def validate(self):
5827 
    return
5828 
 
5829 
 
94 ashish 5830 
  def __repr__(self):
5831 
    L = ['%s=%r' % (key, value)
5832 
      for key, value in self.__dict__.iteritems()]
5833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5834 
 
5835 
  def __eq__(self, other):
5836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5837 
 
5838 
  def __ne__(self, other):
5839 
    return not (self == other)
5840 
 
5326 rajveer 5841 
class createUser_result:
94 ashish 5842 
  """
5843 
  Attributes:
5844 
   - success
559 chandransh 5845 
   - ucex
94 ashish 5846 
  """
5847 
 
5848 
  thrift_spec = (
559 chandransh 5849 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5850 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5851 
  )
5852 
 
559 chandransh 5853 
  def __init__(self, success=None, ucex=None,):
94 ashish 5854 
    self.success = success
559 chandransh 5855 
    self.ucex = ucex
94 ashish 5856 
 
5857 
  def read(self, iprot):
5858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5860 
      return
5861 
    iprot.readStructBegin()
5862 
    while True:
5863 
      (fname, ftype, fid) = iprot.readFieldBegin()
5864 
      if ftype == TType.STOP:
5865 
        break
5866 
      if fid == 0:
5867 
        if ftype == TType.STRUCT:
559 chandransh 5868 
          self.success = User()
94 ashish 5869 
          self.success.read(iprot)
5870 
        else:
5871 
          iprot.skip(ftype)
5872 
      elif fid == 1:
5873 
        if ftype == TType.STRUCT:
559 chandransh 5874 
          self.ucex = UserContextException()
5875 
          self.ucex.read(iprot)
94 ashish 5876 
        else:
5877 
          iprot.skip(ftype)
5878 
      else:
5879 
        iprot.skip(ftype)
5880 
      iprot.readFieldEnd()
5881 
    iprot.readStructEnd()
5882 
 
5883 
  def write(self, oprot):
5884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5886 
      return
5326 rajveer 5887 
    oprot.writeStructBegin('createUser_result')
3431 rajveer 5888 
    if self.success is not None:
94 ashish 5889 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5890 
      self.success.write(oprot)
5891 
      oprot.writeFieldEnd()
3431 rajveer 5892 
    if self.ucex is not None:
559 chandransh 5893 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
5894 
      self.ucex.write(oprot)
94 ashish 5895 
      oprot.writeFieldEnd()
5896 
    oprot.writeFieldStop()
5897 
    oprot.writeStructEnd()
5898 
 
3431 rajveer 5899 
  def validate(self):
5900 
    return
5901 
 
5902 
 
94 ashish 5903 
  def __repr__(self):
5904 
    L = ['%s=%r' % (key, value)
5905 
      for key, value in self.__dict__.iteritems()]
5906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5907 
 
5908 
  def __eq__(self, other):
5909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5910 
 
5911 
  def __ne__(self, other):
5912 
    return not (self == other)
5913 
 
5326 rajveer 5914 
class updateUser_args:
94 ashish 5915 
  """
5916 
  Attributes:
5326 rajveer 5917 
   - user
94 ashish 5918 
  """
5919 
 
5920 
  thrift_spec = (
5921 
    None, # 0
5326 rajveer 5922 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 5923 
  )
5924 
 
5326 rajveer 5925 
  def __init__(self, user=None,):
5926 
    self.user = user
94 ashish 5927 
 
5928 
  def read(self, iprot):
5929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5931 
      return
5932 
    iprot.readStructBegin()
5933 
    while True:
5934 
      (fname, ftype, fid) = iprot.readFieldBegin()
5935 
      if ftype == TType.STOP:
5936 
        break
5937 
      if fid == 1:
5326 rajveer 5938 
        if ftype == TType.STRUCT:
5939 
          self.user = User()
5940 
          self.user.read(iprot)
94 ashish 5941 
        else:
5942 
          iprot.skip(ftype)
5943 
      else:
5944 
        iprot.skip(ftype)
5945 
      iprot.readFieldEnd()
5946 
    iprot.readStructEnd()
5947 
 
5948 
  def write(self, oprot):
5949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5951 
      return
5326 rajveer 5952 
    oprot.writeStructBegin('updateUser_args')
5953 
    if self.user is not None:
5954 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
5955 
      self.user.write(oprot)
94 ashish 5956 
      oprot.writeFieldEnd()
5957 
    oprot.writeFieldStop()
5958 
    oprot.writeStructEnd()
5959 
 
3431 rajveer 5960 
  def validate(self):
5961 
    return
5962 
 
5963 
 
94 ashish 5964 
  def __repr__(self):
5965 
    L = ['%s=%r' % (key, value)
5966 
      for key, value in self.__dict__.iteritems()]
5967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5968 
 
5969 
  def __eq__(self, other):
5970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5971 
 
5972 
  def __ne__(self, other):
5973 
    return not (self == other)
5974 
 
5326 rajveer 5975 
class updateUser_result:
94 ashish 5976 
  """
5977 
  Attributes:
5978 
   - success
559 chandransh 5979 
   - ucex
94 ashish 5980 
  """
5981 
 
5982 
  thrift_spec = (
5326 rajveer 5983 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
559 chandransh 5984 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 5985 
  )
5986 
 
559 chandransh 5987 
  def __init__(self, success=None, ucex=None,):
94 ashish 5988 
    self.success = success
559 chandransh 5989 
    self.ucex = ucex
94 ashish 5990 
 
5991 
  def read(self, iprot):
5992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5994 
      return
5995 
    iprot.readStructBegin()
5996 
    while True:
5997 
      (fname, ftype, fid) = iprot.readFieldBegin()
5998 
      if ftype == TType.STOP:
5999 
        break
6000 
      if fid == 0:
5326 rajveer 6001 
        if ftype == TType.STRUCT:
6002 
          self.success = User()
6003 
          self.success.read(iprot)
94 ashish 6004 
        else:
6005 
          iprot.skip(ftype)
6006 
      elif fid == 1:
6007 
        if ftype == TType.STRUCT:
559 chandransh 6008 
          self.ucex = UserContextException()
6009 
          self.ucex.read(iprot)
94 ashish 6010 
        else:
6011 
          iprot.skip(ftype)
6012 
      else:
6013 
        iprot.skip(ftype)
6014 
      iprot.readFieldEnd()
6015 
    iprot.readStructEnd()
6016 
 
6017 
  def write(self, oprot):
6018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6020 
      return
5326 rajveer 6021 
    oprot.writeStructBegin('updateUser_result')
3431 rajveer 6022 
    if self.success is not None:
5326 rajveer 6023 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6024 
      self.success.write(oprot)
94 ashish 6025 
      oprot.writeFieldEnd()
3431 rajveer 6026 
    if self.ucex is not None:
559 chandransh 6027 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
6028 
      self.ucex.write(oprot)
94 ashish 6029 
      oprot.writeFieldEnd()
6030 
    oprot.writeFieldStop()
6031 
    oprot.writeStructEnd()
6032 
 
3431 rajveer 6033 
  def validate(self):
6034 
    return
6035 
 
6036 
 
94 ashish 6037 
  def __repr__(self):
6038 
    L = ['%s=%r' % (key, value)
6039 
      for key, value in self.__dict__.iteritems()]
6040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6041 
 
6042 
  def __eq__(self, other):
6043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6044 
 
6045 
  def __ne__(self, other):
6046 
    return not (self == other)
6047 
 
559 chandransh 6048 
class authenticateUser_args:
94 ashish 6049 
  """
6050 
  Attributes:
6051 
   - email
6052 
   - password
6053 
  """
6054 
 
6055 
  thrift_spec = (
6056 
    None, # 0
6057 
    (1, TType.STRING, 'email', None, None, ), # 1
6058 
    (2, TType.STRING, 'password', None, None, ), # 2
6059 
  )
6060 
 
6061 
  def __init__(self, email=None, password=None,):
6062 
    self.email = email
6063 
    self.password = password
6064 
 
6065 
  def read(self, iprot):
6066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6068 
      return
6069 
    iprot.readStructBegin()
6070 
    while True:
6071 
      (fname, ftype, fid) = iprot.readFieldBegin()
6072 
      if ftype == TType.STOP:
6073 
        break
6074 
      if fid == 1:
6075 
        if ftype == TType.STRING:
6076 
          self.email = iprot.readString();
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      elif fid == 2:
6080 
        if ftype == TType.STRING:
6081 
          self.password = iprot.readString();
6082 
        else:
6083 
          iprot.skip(ftype)
6084 
      else:
6085 
        iprot.skip(ftype)
6086 
      iprot.readFieldEnd()
6087 
    iprot.readStructEnd()
6088 
 
6089 
  def write(self, oprot):
6090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6092 
      return
559 chandransh 6093 
    oprot.writeStructBegin('authenticateUser_args')
3431 rajveer 6094 
    if self.email is not None:
94 ashish 6095 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6096 
      oprot.writeString(self.email)
6097 
      oprot.writeFieldEnd()
3431 rajveer 6098 
    if self.password is not None:
94 ashish 6099 
      oprot.writeFieldBegin('password', TType.STRING, 2)
6100 
      oprot.writeString(self.password)
6101 
      oprot.writeFieldEnd()
6102 
    oprot.writeFieldStop()
6103 
    oprot.writeStructEnd()
6104 
 
3431 rajveer 6105 
  def validate(self):
6106 
    return
6107 
 
6108 
 
94 ashish 6109 
  def __repr__(self):
6110 
    L = ['%s=%r' % (key, value)
6111 
      for key, value in self.__dict__.iteritems()]
6112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6113 
 
6114 
  def __eq__(self, other):
6115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6116 
 
6117 
  def __ne__(self, other):
6118 
    return not (self == other)
6119 
 
559 chandransh 6120 
class authenticateUser_result:
94 ashish 6121 
  """
6122 
  Attributes:
6123 
   - success
559 chandransh 6124 
   - auex
94 ashish 6125 
  """
6126 
 
6127 
  thrift_spec = (
559 chandransh 6128 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
6129 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 6130 
  )
6131 
 
559 chandransh 6132 
  def __init__(self, success=None, auex=None,):
94 ashish 6133 
    self.success = success
559 chandransh 6134 
    self.auex = auex
94 ashish 6135 
 
6136 
  def read(self, iprot):
6137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6139 
      return
6140 
    iprot.readStructBegin()
6141 
    while True:
6142 
      (fname, ftype, fid) = iprot.readFieldBegin()
6143 
      if ftype == TType.STOP:
6144 
        break
6145 
      if fid == 0:
6146 
        if ftype == TType.STRUCT:
559 chandransh 6147 
          self.success = User()
94 ashish 6148 
          self.success.read(iprot)
6149 
        else:
6150 
          iprot.skip(ftype)
6151 
      elif fid == 1:
6152 
        if ftype == TType.STRUCT:
559 chandransh 6153 
          self.auex = AuthenticationException()
6154 
          self.auex.read(iprot)
94 ashish 6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      else:
6158 
        iprot.skip(ftype)
6159 
      iprot.readFieldEnd()
6160 
    iprot.readStructEnd()
6161 
 
6162 
  def write(self, oprot):
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6165 
      return
559 chandransh 6166 
    oprot.writeStructBegin('authenticateUser_result')
3431 rajveer 6167 
    if self.success is not None:
94 ashish 6168 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6169 
      self.success.write(oprot)
6170 
      oprot.writeFieldEnd()
3431 rajveer 6171 
    if self.auex is not None:
559 chandransh 6172 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
6173 
      self.auex.write(oprot)
94 ashish 6174 
      oprot.writeFieldEnd()
6175 
    oprot.writeFieldStop()
6176 
    oprot.writeStructEnd()
6177 
 
3431 rajveer 6178 
  def validate(self):
6179 
    return
6180 
 
6181 
 
94 ashish 6182 
  def __repr__(self):
6183 
    L = ['%s=%r' % (key, value)
6184 
      for key, value in self.__dict__.iteritems()]
6185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6186 
 
6187 
  def __eq__(self, other):
6188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6189 
 
6190 
  def __ne__(self, other):
6191 
    return not (self == other)
6192 
 
559 chandransh 6193 
class userExists_args:
122 ashish 6194 
  """
6195 
  Attributes:
559 chandransh 6196 
   - email
122 ashish 6197 
  """
6198 
 
6199 
  thrift_spec = (
6200 
    None, # 0
559 chandransh 6201 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 6202 
  )
6203 
 
559 chandransh 6204 
  def __init__(self, email=None,):
6205 
    self.email = email
122 ashish 6206 
 
6207 
  def read(self, iprot):
6208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6210 
      return
6211 
    iprot.readStructBegin()
6212 
    while True:
6213 
      (fname, ftype, fid) = iprot.readFieldBegin()
6214 
      if ftype == TType.STOP:
6215 
        break
6216 
      if fid == 1:
6217 
        if ftype == TType.STRING:
559 chandransh 6218 
          self.email = iprot.readString();
122 ashish 6219 
        else:
6220 
          iprot.skip(ftype)
559 chandransh 6221 
      else:
6222 
        iprot.skip(ftype)
6223 
      iprot.readFieldEnd()
6224 
    iprot.readStructEnd()
6225 
 
6226 
  def write(self, oprot):
6227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6229 
      return
6230 
    oprot.writeStructBegin('userExists_args')
3431 rajveer 6231 
    if self.email is not None:
559 chandransh 6232 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6233 
      oprot.writeString(self.email)
6234 
      oprot.writeFieldEnd()
6235 
    oprot.writeFieldStop()
6236 
    oprot.writeStructEnd()
6237 
 
3431 rajveer 6238 
  def validate(self):
6239 
    return
6240 
 
6241 
 
559 chandransh 6242 
  def __repr__(self):
6243 
    L = ['%s=%r' % (key, value)
6244 
      for key, value in self.__dict__.iteritems()]
6245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6246 
 
6247 
  def __eq__(self, other):
6248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6249 
 
6250 
  def __ne__(self, other):
6251 
    return not (self == other)
6252 
 
6253 
class userExists_result:
6254 
  """
6255 
  Attributes:
6256 
   - success
6257 
   - ucx
6258 
  """
6259 
 
6260 
  thrift_spec = (
6261 
    (0, TType.BOOL, 'success', None, None, ), # 0
6262 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6263 
  )
6264 
 
6265 
  def __init__(self, success=None, ucx=None,):
6266 
    self.success = success
6267 
    self.ucx = ucx
6268 
 
6269 
  def read(self, iprot):
6270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6272 
      return
6273 
    iprot.readStructBegin()
6274 
    while True:
6275 
      (fname, ftype, fid) = iprot.readFieldBegin()
6276 
      if ftype == TType.STOP:
6277 
        break
6278 
      if fid == 0:
6279 
        if ftype == TType.BOOL:
6280 
          self.success = iprot.readBool();
6281 
        else:
6282 
          iprot.skip(ftype)
6283 
      elif fid == 1:
6284 
        if ftype == TType.STRUCT:
6285 
          self.ucx = UserContextException()
6286 
          self.ucx.read(iprot)
6287 
        else:
6288 
          iprot.skip(ftype)
6289 
      else:
6290 
        iprot.skip(ftype)
6291 
      iprot.readFieldEnd()
6292 
    iprot.readStructEnd()
6293 
 
6294 
  def write(self, oprot):
6295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6297 
      return
6298 
    oprot.writeStructBegin('userExists_result')
3431 rajveer 6299 
    if self.success is not None:
559 chandransh 6300 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6301 
      oprot.writeBool(self.success)
6302 
      oprot.writeFieldEnd()
3431 rajveer 6303 
    if self.ucx is not None:
559 chandransh 6304 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6305 
      self.ucx.write(oprot)
6306 
      oprot.writeFieldEnd()
6307 
    oprot.writeFieldStop()
6308 
    oprot.writeStructEnd()
6309 
 
3431 rajveer 6310 
  def validate(self):
6311 
    return
6312 
 
6313 
 
559 chandransh 6314 
  def __repr__(self):
6315 
    L = ['%s=%r' % (key, value)
6316 
      for key, value in self.__dict__.iteritems()]
6317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6318 
 
6319 
  def __eq__(self, other):
6320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6321 
 
6322 
  def __ne__(self, other):
6323 
    return not (self == other)
6324 
 
6325 
class addAddressForUser_args:
6326 
  """
6327 
  Attributes:
6328 
   - userId
6329 
   - address
6330 
   - setDefault
6331 
  """
6332 
 
6333 
  thrift_spec = (
6334 
    None, # 0
6335 
    (1, TType.I64, 'userId', None, None, ), # 1
6336 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 6337 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 6338 
  )
6339 
 
567 rajveer 6340 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 6341 
    self.userId = userId
6342 
    self.address = address
6343 
    self.setDefault = setDefault
6344 
 
6345 
  def read(self, iprot):
6346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6348 
      return
6349 
    iprot.readStructBegin()
6350 
    while True:
6351 
      (fname, ftype, fid) = iprot.readFieldBegin()
6352 
      if ftype == TType.STOP:
6353 
        break
6354 
      if fid == 1:
6355 
        if ftype == TType.I64:
6356 
          self.userId = iprot.readI64();
6357 
        else:
6358 
          iprot.skip(ftype)
122 ashish 6359 
      elif fid == 2:
559 chandransh 6360 
        if ftype == TType.STRUCT:
6361 
          self.address = Address()
6362 
          self.address.read(iprot)
122 ashish 6363 
        else:
6364 
          iprot.skip(ftype)
6365 
      elif fid == 3:
6366 
        if ftype == TType.BOOL:
559 chandransh 6367 
          self.setDefault = iprot.readBool();
122 ashish 6368 
        else:
6369 
          iprot.skip(ftype)
6370 
      else:
6371 
        iprot.skip(ftype)
6372 
      iprot.readFieldEnd()
6373 
    iprot.readStructEnd()
6374 
 
6375 
  def write(self, oprot):
6376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6378 
      return
559 chandransh 6379 
    oprot.writeStructBegin('addAddressForUser_args')
3431 rajveer 6380 
    if self.userId is not None:
559 chandransh 6381 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6382 
      oprot.writeI64(self.userId)
122 ashish 6383 
      oprot.writeFieldEnd()
3431 rajveer 6384 
    if self.address is not None:
559 chandransh 6385 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
6386 
      self.address.write(oprot)
122 ashish 6387 
      oprot.writeFieldEnd()
3431 rajveer 6388 
    if self.setDefault is not None:
567 rajveer 6389 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 6390 
      oprot.writeBool(self.setDefault)
6391 
      oprot.writeFieldEnd()
122 ashish 6392 
    oprot.writeFieldStop()
6393 
    oprot.writeStructEnd()
6394 
 
3431 rajveer 6395 
  def validate(self):
6396 
    return
6397 
 
6398 
 
122 ashish 6399 
  def __repr__(self):
6400 
    L = ['%s=%r' % (key, value)
6401 
      for key, value in self.__dict__.iteritems()]
6402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6403 
 
6404 
  def __eq__(self, other):
6405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6406 
 
6407 
  def __ne__(self, other):
6408 
    return not (self == other)
6409 
 
559 chandransh 6410 
class addAddressForUser_result:
122 ashish 6411 
  """
6412 
  Attributes:
6413 
   - success
559 chandransh 6414 
   - ucx
122 ashish 6415 
  """
6416 
 
6417 
  thrift_spec = (
567 rajveer 6418 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6419 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 6420 
  )
6421 
 
559 chandransh 6422 
  def __init__(self, success=None, ucx=None,):
122 ashish 6423 
    self.success = success
559 chandransh 6424 
    self.ucx = ucx
122 ashish 6425 
 
6426 
  def read(self, iprot):
6427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6429 
      return
6430 
    iprot.readStructBegin()
6431 
    while True:
6432 
      (fname, ftype, fid) = iprot.readFieldBegin()
6433 
      if ftype == TType.STOP:
6434 
        break
6435 
      if fid == 0:
567 rajveer 6436 
        if ftype == TType.I64:
6437 
          self.success = iprot.readI64();
122 ashish 6438 
        else:
6439 
          iprot.skip(ftype)
6440 
      elif fid == 1:
6441 
        if ftype == TType.STRUCT:
559 chandransh 6442 
          self.ucx = UserContextException()
6443 
          self.ucx.read(iprot)
122 ashish 6444 
        else:
6445 
          iprot.skip(ftype)
6446 
      else:
6447 
        iprot.skip(ftype)
6448 
      iprot.readFieldEnd()
6449 
    iprot.readStructEnd()
6450 
 
6451 
  def write(self, oprot):
6452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6454 
      return
559 chandransh 6455 
    oprot.writeStructBegin('addAddressForUser_result')
3431 rajveer 6456 
    if self.success is not None:
567 rajveer 6457 
      oprot.writeFieldBegin('success', TType.I64, 0)
6458 
      oprot.writeI64(self.success)
122 ashish 6459 
      oprot.writeFieldEnd()
3431 rajveer 6460 
    if self.ucx is not None:
559 chandransh 6461 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6462 
      self.ucx.write(oprot)
122 ashish 6463 
      oprot.writeFieldEnd()
6464 
    oprot.writeFieldStop()
6465 
    oprot.writeStructEnd()
6466 
 
3431 rajveer 6467 
  def validate(self):
6468 
    return
6469 
 
6470 
 
122 ashish 6471 
  def __repr__(self):
6472 
    L = ['%s=%r' % (key, value)
6473 
      for key, value in self.__dict__.iteritems()]
6474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6475 
 
6476 
  def __eq__(self, other):
6477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6478 
 
6479 
  def __ne__(self, other):
6480 
    return not (self == other)
6481 
 
559 chandransh 6482 
class removeAddressForUser_args:
94 ashish 6483 
  """
6484 
  Attributes:
559 chandransh 6485 
   - userid
6486 
   - addressId
94 ashish 6487 
  """
6488 
 
6489 
  thrift_spec = (
6490 
    None, # 0
559 chandransh 6491 
    (1, TType.I64, 'userid', None, None, ), # 1
6492 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 6493 
  )
6494 
 
559 chandransh 6495 
  def __init__(self, userid=None, addressId=None,):
6496 
    self.userid = userid
6497 
    self.addressId = addressId
94 ashish 6498 
 
6499 
  def read(self, iprot):
6500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6502 
      return
6503 
    iprot.readStructBegin()
6504 
    while True:
6505 
      (fname, ftype, fid) = iprot.readFieldBegin()
6506 
      if ftype == TType.STOP:
6507 
        break
6508 
      if fid == 1:
559 chandransh 6509 
        if ftype == TType.I64:
6510 
          self.userid = iprot.readI64();
94 ashish 6511 
        else:
6512 
          iprot.skip(ftype)
559 chandransh 6513 
      elif fid == 2:
6514 
        if ftype == TType.I64:
6515 
          self.addressId = iprot.readI64();
6516 
        else:
6517 
          iprot.skip(ftype)
94 ashish 6518 
      else:
6519 
        iprot.skip(ftype)
6520 
      iprot.readFieldEnd()
6521 
    iprot.readStructEnd()
6522 
 
6523 
  def write(self, oprot):
6524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6526 
      return
559 chandransh 6527 
    oprot.writeStructBegin('removeAddressForUser_args')
3431 rajveer 6528 
    if self.userid is not None:
559 chandransh 6529 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6530 
      oprot.writeI64(self.userid)
94 ashish 6531 
      oprot.writeFieldEnd()
3431 rajveer 6532 
    if self.addressId is not None:
559 chandransh 6533 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6534 
      oprot.writeI64(self.addressId)
6535 
      oprot.writeFieldEnd()
94 ashish 6536 
    oprot.writeFieldStop()
6537 
    oprot.writeStructEnd()
6538 
 
3431 rajveer 6539 
  def validate(self):
6540 
    return
6541 
 
6542 
 
94 ashish 6543 
  def __repr__(self):
6544 
    L = ['%s=%r' % (key, value)
6545 
      for key, value in self.__dict__.iteritems()]
6546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6547 
 
6548 
  def __eq__(self, other):
6549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6550 
 
6551 
  def __ne__(self, other):
6552 
    return not (self == other)
6553 
 
559 chandransh 6554 
class removeAddressForUser_result:
94 ashish 6555 
  """
6556 
  Attributes:
6557 
   - success
6558 
   - ucx
6559 
  """
6560 
 
6561 
  thrift_spec = (
6562 
    (0, TType.BOOL, 'success', None, None, ), # 0
6563 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6564 
  )
6565 
 
6566 
  def __init__(self, success=None, ucx=None,):
6567 
    self.success = success
6568 
    self.ucx = ucx
6569 
 
6570 
  def read(self, iprot):
6571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6573 
      return
6574 
    iprot.readStructBegin()
6575 
    while True:
6576 
      (fname, ftype, fid) = iprot.readFieldBegin()
6577 
      if ftype == TType.STOP:
6578 
        break
6579 
      if fid == 0:
6580 
        if ftype == TType.BOOL:
6581 
          self.success = iprot.readBool();
6582 
        else:
6583 
          iprot.skip(ftype)
6584 
      elif fid == 1:
6585 
        if ftype == TType.STRUCT:
6586 
          self.ucx = UserContextException()
6587 
          self.ucx.read(iprot)
6588 
        else:
6589 
          iprot.skip(ftype)
6590 
      else:
6591 
        iprot.skip(ftype)
6592 
      iprot.readFieldEnd()
6593 
    iprot.readStructEnd()
6594 
 
6595 
  def write(self, oprot):
6596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6598 
      return
559 chandransh 6599 
    oprot.writeStructBegin('removeAddressForUser_result')
3431 rajveer 6600 
    if self.success is not None:
94 ashish 6601 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6602 
      oprot.writeBool(self.success)
6603 
      oprot.writeFieldEnd()
3431 rajveer 6604 
    if self.ucx is not None:
94 ashish 6605 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6606 
      self.ucx.write(oprot)
6607 
      oprot.writeFieldEnd()
6608 
    oprot.writeFieldStop()
6609 
    oprot.writeStructEnd()
6610 
 
3431 rajveer 6611 
  def validate(self):
6612 
    return
6613 
 
6614 
 
94 ashish 6615 
  def __repr__(self):
6616 
    L = ['%s=%r' % (key, value)
6617 
      for key, value in self.__dict__.iteritems()]
6618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6619 
 
6620 
  def __eq__(self, other):
6621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6622 
 
6623 
  def __ne__(self, other):
6624 
    return not (self == other)
6625 
 
559 chandransh 6626 
class setUserAsLoggedIn_args:
94 ashish 6627 
  """
6628 
  Attributes:
559 chandransh 6629 
   - userId
94 ashish 6630 
   - timestamp
6631 
  """
6632 
 
6633 
  thrift_spec = (
6634 
    None, # 0
559 chandransh 6635 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 6636 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6637 
  )
6638 
 
559 chandransh 6639 
  def __init__(self, userId=None, timestamp=None,):
6640 
    self.userId = userId
94 ashish 6641 
    self.timestamp = timestamp
6642 
 
6643 
  def read(self, iprot):
6644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6646 
      return
6647 
    iprot.readStructBegin()
6648 
    while True:
6649 
      (fname, ftype, fid) = iprot.readFieldBegin()
6650 
      if ftype == TType.STOP:
6651 
        break
6652 
      if fid == 1:
559 chandransh 6653 
        if ftype == TType.I64:
6654 
          self.userId = iprot.readI64();
94 ashish 6655 
        else:
6656 
          iprot.skip(ftype)
6657 
      elif fid == 2:
6658 
        if ftype == TType.I64:
6659 
          self.timestamp = iprot.readI64();
6660 
        else:
6661 
          iprot.skip(ftype)
6662 
      else:
6663 
        iprot.skip(ftype)
6664 
      iprot.readFieldEnd()
6665 
    iprot.readStructEnd()
6666 
 
6667 
  def write(self, oprot):
6668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6670 
      return
559 chandransh 6671 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3431 rajveer 6672 
    if self.userId is not None:
559 chandransh 6673 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6674 
      oprot.writeI64(self.userId)
94 ashish 6675 
      oprot.writeFieldEnd()
3431 rajveer 6676 
    if self.timestamp is not None:
94 ashish 6677 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6678 
      oprot.writeI64(self.timestamp)
6679 
      oprot.writeFieldEnd()
6680 
    oprot.writeFieldStop()
6681 
    oprot.writeStructEnd()
6682 
 
3431 rajveer 6683 
  def validate(self):
6684 
    return
6685 
 
6686 
 
94 ashish 6687 
  def __repr__(self):
6688 
    L = ['%s=%r' % (key, value)
6689 
      for key, value in self.__dict__.iteritems()]
6690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6691 
 
6692 
  def __eq__(self, other):
6693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6694 
 
6695 
  def __ne__(self, other):
6696 
    return not (self == other)
6697 
 
559 chandransh 6698 
class setUserAsLoggedIn_result:
94 ashish 6699 
  """
6700 
  Attributes:
6701 
   - success
6702 
   - ucx
6703 
  """
6704 
 
6705 
  thrift_spec = (
6706 
    (0, TType.BOOL, 'success', None, None, ), # 0
6707 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6708 
  )
6709 
 
6710 
  def __init__(self, success=None, ucx=None,):
6711 
    self.success = success
6712 
    self.ucx = ucx
6713 
 
6714 
  def read(self, iprot):
6715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6717 
      return
6718 
    iprot.readStructBegin()
6719 
    while True:
6720 
      (fname, ftype, fid) = iprot.readFieldBegin()
6721 
      if ftype == TType.STOP:
6722 
        break
6723 
      if fid == 0:
6724 
        if ftype == TType.BOOL:
6725 
          self.success = iprot.readBool();
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      elif fid == 1:
6729 
        if ftype == TType.STRUCT:
6730 
          self.ucx = UserContextException()
6731 
          self.ucx.read(iprot)
6732 
        else:
6733 
          iprot.skip(ftype)
6734 
      else:
6735 
        iprot.skip(ftype)
6736 
      iprot.readFieldEnd()
6737 
    iprot.readStructEnd()
6738 
 
6739 
  def write(self, oprot):
6740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6742 
      return
559 chandransh 6743 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3431 rajveer 6744 
    if self.success is not None:
94 ashish 6745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6746 
      oprot.writeBool(self.success)
6747 
      oprot.writeFieldEnd()
3431 rajveer 6748 
    if self.ucx is not None:
94 ashish 6749 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6750 
      self.ucx.write(oprot)
6751 
      oprot.writeFieldEnd()
6752 
    oprot.writeFieldStop()
6753 
    oprot.writeStructEnd()
6754 
 
3431 rajveer 6755 
  def validate(self):
6756 
    return
6757 
 
6758 
 
94 ashish 6759 
  def __repr__(self):
6760 
    L = ['%s=%r' % (key, value)
6761 
      for key, value in self.__dict__.iteritems()]
6762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6763 
 
6764 
  def __eq__(self, other):
6765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6766 
 
6767 
  def __ne__(self, other):
6768 
    return not (self == other)
6769 
 
559 chandransh 6770 
class setUserAsLoggedOut_args:
94 ashish 6771 
  """
6772 
  Attributes:
6773 
   - userid
6774 
   - timestamp
6775 
  """
6776 
 
6777 
  thrift_spec = (
6778 
    None, # 0
559 chandransh 6779 
    (1, TType.I64, 'userid', None, None, ), # 1
6780 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 6781 
  )
6782 
 
559 chandransh 6783 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 6784 
    self.userid = userid
6785 
    self.timestamp = timestamp
6786 
 
6787 
  def read(self, iprot):
6788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6790 
      return
6791 
    iprot.readStructBegin()
6792 
    while True:
6793 
      (fname, ftype, fid) = iprot.readFieldBegin()
6794 
      if ftype == TType.STOP:
6795 
        break
6796 
      if fid == 1:
6797 
        if ftype == TType.I64:
6798 
          self.userid = iprot.readI64();
6799 
        else:
6800 
          iprot.skip(ftype)
559 chandransh 6801 
      elif fid == 2:
94 ashish 6802 
        if ftype == TType.I64:
6803 
          self.timestamp = iprot.readI64();
6804 
        else:
6805 
          iprot.skip(ftype)
6806 
      else:
6807 
        iprot.skip(ftype)
6808 
      iprot.readFieldEnd()
6809 
    iprot.readStructEnd()
6810 
 
6811 
  def write(self, oprot):
6812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6814 
      return
559 chandransh 6815 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3431 rajveer 6816 
    if self.userid is not None:
559 chandransh 6817 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 6818 
      oprot.writeI64(self.userid)
6819 
      oprot.writeFieldEnd()
3431 rajveer 6820 
    if self.timestamp is not None:
559 chandransh 6821 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 6822 
      oprot.writeI64(self.timestamp)
6823 
      oprot.writeFieldEnd()
6824 
    oprot.writeFieldStop()
6825 
    oprot.writeStructEnd()
6826 
 
3431 rajveer 6827 
  def validate(self):
6828 
    return
6829 
 
6830 
 
94 ashish 6831 
  def __repr__(self):
6832 
    L = ['%s=%r' % (key, value)
6833 
      for key, value in self.__dict__.iteritems()]
6834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6835 
 
6836 
  def __eq__(self, other):
6837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6838 
 
6839 
  def __ne__(self, other):
6840 
    return not (self == other)
6841 
 
559 chandransh 6842 
class setUserAsLoggedOut_result:
94 ashish 6843 
  """
6844 
  Attributes:
6845 
   - success
6846 
   - ucx
6847 
  """
6848 
 
6849 
  thrift_spec = (
6850 
    (0, TType.BOOL, 'success', None, None, ), # 0
6851 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6852 
  )
6853 
 
6854 
  def __init__(self, success=None, ucx=None,):
6855 
    self.success = success
6856 
    self.ucx = ucx
6857 
 
6858 
  def read(self, iprot):
6859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6861 
      return
6862 
    iprot.readStructBegin()
6863 
    while True:
6864 
      (fname, ftype, fid) = iprot.readFieldBegin()
6865 
      if ftype == TType.STOP:
6866 
        break
6867 
      if fid == 0:
6868 
        if ftype == TType.BOOL:
6869 
          self.success = iprot.readBool();
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      elif fid == 1:
6873 
        if ftype == TType.STRUCT:
6874 
          self.ucx = UserContextException()
6875 
          self.ucx.read(iprot)
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      else:
6879 
        iprot.skip(ftype)
6880 
      iprot.readFieldEnd()
6881 
    iprot.readStructEnd()
6882 
 
6883 
  def write(self, oprot):
6884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6886 
      return
559 chandransh 6887 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3431 rajveer 6888 
    if self.success is not None:
94 ashish 6889 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6890 
      oprot.writeBool(self.success)
6891 
      oprot.writeFieldEnd()
3431 rajveer 6892 
    if self.ucx is not None:
94 ashish 6893 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6894 
      self.ucx.write(oprot)
6895 
      oprot.writeFieldEnd()
6896 
    oprot.writeFieldStop()
6897 
    oprot.writeStructEnd()
6898 
 
3431 rajveer 6899 
  def validate(self):
6900 
    return
6901 
 
6902 
 
94 ashish 6903 
  def __repr__(self):
6904 
    L = ['%s=%r' % (key, value)
6905 
      for key, value in self.__dict__.iteritems()]
6906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6907 
 
6908 
  def __eq__(self, other):
6909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6910 
 
6911 
  def __ne__(self, other):
6912 
    return not (self == other)
6913 
 
559 chandransh 6914 
class setDefaultAddress_args:
94 ashish 6915 
  """
6916 
  Attributes:
6917 
   - userid
6918 
   - addressId
6919 
  """
6920 
 
6921 
  thrift_spec = (
6922 
    None, # 0
6923 
    (1, TType.I64, 'userid', None, None, ), # 1
6924 
    (2, TType.I64, 'addressId', None, None, ), # 2
6925 
  )
6926 
 
6927 
  def __init__(self, userid=None, addressId=None,):
6928 
    self.userid = userid
6929 
    self.addressId = addressId
6930 
 
6931 
  def read(self, iprot):
6932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6934 
      return
6935 
    iprot.readStructBegin()
6936 
    while True:
6937 
      (fname, ftype, fid) = iprot.readFieldBegin()
6938 
      if ftype == TType.STOP:
6939 
        break
6940 
      if fid == 1:
6941 
        if ftype == TType.I64:
6942 
          self.userid = iprot.readI64();
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      elif fid == 2:
6946 
        if ftype == TType.I64:
6947 
          self.addressId = iprot.readI64();
6948 
        else:
6949 
          iprot.skip(ftype)
6950 
      else:
6951 
        iprot.skip(ftype)
6952 
      iprot.readFieldEnd()
6953 
    iprot.readStructEnd()
6954 
 
6955 
  def write(self, oprot):
6956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6958 
      return
559 chandransh 6959 
    oprot.writeStructBegin('setDefaultAddress_args')
3431 rajveer 6960 
    if self.userid is not None:
94 ashish 6961 
      oprot.writeFieldBegin('userid', TType.I64, 1)
6962 
      oprot.writeI64(self.userid)
6963 
      oprot.writeFieldEnd()
3431 rajveer 6964 
    if self.addressId is not None:
94 ashish 6965 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
6966 
      oprot.writeI64(self.addressId)
6967 
      oprot.writeFieldEnd()
6968 
    oprot.writeFieldStop()
6969 
    oprot.writeStructEnd()
6970 
 
3431 rajveer 6971 
  def validate(self):
6972 
    return
6973 
 
6974 
 
94 ashish 6975 
  def __repr__(self):
6976 
    L = ['%s=%r' % (key, value)
6977 
      for key, value in self.__dict__.iteritems()]
6978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6979 
 
6980 
  def __eq__(self, other):
6981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6982 
 
6983 
  def __ne__(self, other):
6984 
    return not (self == other)
6985 
 
559 chandransh 6986 
class setDefaultAddress_result:
94 ashish 6987 
  """
6988 
  Attributes:
6989 
   - success
6990 
   - ucx
6991 
  """
6992 
 
6993 
  thrift_spec = (
6994 
    (0, TType.BOOL, 'success', None, None, ), # 0
6995 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6996 
  )
6997 
 
6998 
  def __init__(self, success=None, ucx=None,):
6999 
    self.success = success
7000 
    self.ucx = ucx
7001 
 
7002 
  def read(self, iprot):
7003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7005 
      return
7006 
    iprot.readStructBegin()
7007 
    while True:
7008 
      (fname, ftype, fid) = iprot.readFieldBegin()
7009 
      if ftype == TType.STOP:
7010 
        break
7011 
      if fid == 0:
7012 
        if ftype == TType.BOOL:
7013 
          self.success = iprot.readBool();
7014 
        else:
7015 
          iprot.skip(ftype)
7016 
      elif fid == 1:
7017 
        if ftype == TType.STRUCT:
7018 
          self.ucx = UserContextException()
7019 
          self.ucx.read(iprot)
7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      else:
7023 
        iprot.skip(ftype)
7024 
      iprot.readFieldEnd()
7025 
    iprot.readStructEnd()
7026 
 
7027 
  def write(self, oprot):
7028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7030 
      return
559 chandransh 7031 
    oprot.writeStructBegin('setDefaultAddress_result')
3431 rajveer 7032 
    if self.success is not None:
94 ashish 7033 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7034 
      oprot.writeBool(self.success)
7035 
      oprot.writeFieldEnd()
3431 rajveer 7036 
    if self.ucx is not None:
94 ashish 7037 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7038 
      self.ucx.write(oprot)
7039 
      oprot.writeFieldEnd()
7040 
    oprot.writeFieldStop()
7041 
    oprot.writeStructEnd()
7042 
 
3431 rajveer 7043 
  def validate(self):
7044 
    return
7045 
 
7046 
 
94 ashish 7047 
  def __repr__(self):
7048 
    L = ['%s=%r' % (key, value)
7049 
      for key, value in self.__dict__.iteritems()]
7050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7051 
 
7052 
  def __eq__(self, other):
7053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7054 
 
7055 
  def __ne__(self, other):
7056 
    return not (self == other)
7057 
 
559 chandransh 7058 
class updatePassword_args:
94 ashish 7059 
  """
7060 
  Attributes:
559 chandransh 7061 
   - userid
594 rajveer 7062 
   - oldPassword
7063 
   - newPassword
94 ashish 7064 
  """
7065 
 
7066 
  thrift_spec = (
7067 
    None, # 0
559 chandransh 7068 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 7069 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
7070 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 7071 
  )
7072 
 
594 rajveer 7073 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 7074 
    self.userid = userid
594 rajveer 7075 
    self.oldPassword = oldPassword
7076 
    self.newPassword = newPassword
94 ashish 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:
559 chandransh 7089 
          self.userid = iprot.readI64();
94 ashish 7090 
        else:
7091 
          iprot.skip(ftype)
7092 
      elif fid == 2:
559 chandransh 7093 
        if ftype == TType.STRING:
594 rajveer 7094 
          self.oldPassword = iprot.readString();
94 ashish 7095 
        else:
7096 
          iprot.skip(ftype)
594 rajveer 7097 
      elif fid == 3:
7098 
        if ftype == TType.STRING:
7099 
          self.newPassword = iprot.readString();
7100 
        else:
7101 
          iprot.skip(ftype)
94 ashish 7102 
      else:
7103 
        iprot.skip(ftype)
7104 
      iprot.readFieldEnd()
7105 
    iprot.readStructEnd()
7106 
 
7107 
  def write(self, oprot):
7108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7110 
      return
559 chandransh 7111 
    oprot.writeStructBegin('updatePassword_args')
3431 rajveer 7112 
    if self.userid is not None:
559 chandransh 7113 
      oprot.writeFieldBegin('userid', TType.I64, 1)
7114 
      oprot.writeI64(self.userid)
94 ashish 7115 
      oprot.writeFieldEnd()
3431 rajveer 7116 
    if self.oldPassword is not None:
594 rajveer 7117 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
7118 
      oprot.writeString(self.oldPassword)
94 ashish 7119 
      oprot.writeFieldEnd()
3431 rajveer 7120 
    if self.newPassword is not None:
594 rajveer 7121 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
7122 
      oprot.writeString(self.newPassword)
7123 
      oprot.writeFieldEnd()
94 ashish 7124 
    oprot.writeFieldStop()
7125 
    oprot.writeStructEnd()
7126 
 
3431 rajveer 7127 
  def validate(self):
7128 
    return
7129 
 
7130 
 
94 ashish 7131 
  def __repr__(self):
7132 
    L = ['%s=%r' % (key, value)
7133 
      for key, value in self.__dict__.iteritems()]
7134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7135 
 
7136 
  def __eq__(self, other):
7137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7138 
 
7139 
  def __ne__(self, other):
7140 
    return not (self == other)
7141 
 
559 chandransh 7142 
class updatePassword_result:
94 ashish 7143 
  """
7144 
  Attributes:
7145 
   - success
7146 
   - ucx
7147 
  """
7148 
 
7149 
  thrift_spec = (
7150 
    (0, TType.BOOL, 'success', None, None, ), # 0
7151 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7152 
  )
7153 
 
7154 
  def __init__(self, success=None, ucx=None,):
7155 
    self.success = success
7156 
    self.ucx = ucx
7157 
 
7158 
  def read(self, iprot):
7159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7161 
      return
7162 
    iprot.readStructBegin()
7163 
    while True:
7164 
      (fname, ftype, fid) = iprot.readFieldBegin()
7165 
      if ftype == TType.STOP:
7166 
        break
7167 
      if fid == 0:
7168 
        if ftype == TType.BOOL:
7169 
          self.success = iprot.readBool();
7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      elif fid == 1:
7173 
        if ftype == TType.STRUCT:
7174 
          self.ucx = UserContextException()
7175 
          self.ucx.read(iprot)
7176 
        else:
7177 
          iprot.skip(ftype)
7178 
      else:
7179 
        iprot.skip(ftype)
7180 
      iprot.readFieldEnd()
7181 
    iprot.readStructEnd()
7182 
 
7183 
  def write(self, oprot):
7184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7186 
      return
559 chandransh 7187 
    oprot.writeStructBegin('updatePassword_result')
3431 rajveer 7188 
    if self.success is not None:
94 ashish 7189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7190 
      oprot.writeBool(self.success)
7191 
      oprot.writeFieldEnd()
3431 rajveer 7192 
    if self.ucx is not None:
94 ashish 7193 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7194 
      self.ucx.write(oprot)
7195 
      oprot.writeFieldEnd()
7196 
    oprot.writeFieldStop()
7197 
    oprot.writeStructEnd()
7198 
 
3431 rajveer 7199 
  def validate(self):
7200 
    return
7201 
 
7202 
 
94 ashish 7203 
  def __repr__(self):
7204 
    L = ['%s=%r' % (key, value)
7205 
      for key, value in self.__dict__.iteritems()]
7206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7207 
 
7208 
  def __eq__(self, other):
7209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7210 
 
7211 
  def __ne__(self, other):
7212 
    return not (self == other)
7213 
 
581 rajveer 7214 
class forgotPassword_args:
7215 
  """
7216 
  Attributes:
7217 
   - email
884 rajveer 7218 
   - newPassword
581 rajveer 7219 
  """
7220 
 
7221 
  thrift_spec = (
7222 
    None, # 0
7223 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 7224 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 7225 
  )
7226 
 
884 rajveer 7227 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 7228 
    self.email = email
884 rajveer 7229 
    self.newPassword = newPassword
581 rajveer 7230 
 
7231 
  def read(self, iprot):
7232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7234 
      return
7235 
    iprot.readStructBegin()
7236 
    while True:
7237 
      (fname, ftype, fid) = iprot.readFieldBegin()
7238 
      if ftype == TType.STOP:
7239 
        break
7240 
      if fid == 1:
7241 
        if ftype == TType.STRING:
7242 
          self.email = iprot.readString();
7243 
        else:
7244 
          iprot.skip(ftype)
884 rajveer 7245 
      elif fid == 2:
7246 
        if ftype == TType.STRING:
7247 
          self.newPassword = iprot.readString();
7248 
        else:
7249 
          iprot.skip(ftype)
581 rajveer 7250 
      else:
7251 
        iprot.skip(ftype)
7252 
      iprot.readFieldEnd()
7253 
    iprot.readStructEnd()
7254 
 
7255 
  def write(self, oprot):
7256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7258 
      return
7259 
    oprot.writeStructBegin('forgotPassword_args')
3431 rajveer 7260 
    if self.email is not None:
581 rajveer 7261 
      oprot.writeFieldBegin('email', TType.STRING, 1)
7262 
      oprot.writeString(self.email)
7263 
      oprot.writeFieldEnd()
3431 rajveer 7264 
    if self.newPassword is not None:
884 rajveer 7265 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
7266 
      oprot.writeString(self.newPassword)
7267 
      oprot.writeFieldEnd()
581 rajveer 7268 
    oprot.writeFieldStop()
7269 
    oprot.writeStructEnd()
7270 
 
3431 rajveer 7271 
  def validate(self):
7272 
    return
7273 
 
7274 
 
581 rajveer 7275 
  def __repr__(self):
7276 
    L = ['%s=%r' % (key, value)
7277 
      for key, value in self.__dict__.iteritems()]
7278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7279 
 
7280 
  def __eq__(self, other):
7281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7282 
 
7283 
  def __ne__(self, other):
7284 
    return not (self == other)
7285 
 
7286 
class forgotPassword_result:
7287 
  """
7288 
  Attributes:
7289 
   - success
7290 
   - ucx
7291 
  """
7292 
 
7293 
  thrift_spec = (
7294 
    (0, TType.BOOL, 'success', None, None, ), # 0
7295 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7296 
  )
7297 
 
7298 
  def __init__(self, success=None, ucx=None,):
7299 
    self.success = success
7300 
    self.ucx = ucx
7301 
 
7302 
  def read(self, iprot):
7303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7305 
      return
7306 
    iprot.readStructBegin()
7307 
    while True:
7308 
      (fname, ftype, fid) = iprot.readFieldBegin()
7309 
      if ftype == TType.STOP:
7310 
        break
7311 
      if fid == 0:
7312 
        if ftype == TType.BOOL:
7313 
          self.success = iprot.readBool();
7314 
        else:
7315 
          iprot.skip(ftype)
7316 
      elif fid == 1:
7317 
        if ftype == TType.STRUCT:
7318 
          self.ucx = UserContextException()
7319 
          self.ucx.read(iprot)
7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      else:
7323 
        iprot.skip(ftype)
7324 
      iprot.readFieldEnd()
7325 
    iprot.readStructEnd()
7326 
 
7327 
  def write(self, oprot):
7328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7330 
      return
7331 
    oprot.writeStructBegin('forgotPassword_result')
3431 rajveer 7332 
    if self.success is not None:
581 rajveer 7333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7334 
      oprot.writeBool(self.success)
7335 
      oprot.writeFieldEnd()
3431 rajveer 7336 
    if self.ucx is not None:
581 rajveer 7337 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7338 
      self.ucx.write(oprot)
7339 
      oprot.writeFieldEnd()
7340 
    oprot.writeFieldStop()
7341 
    oprot.writeStructEnd()
7342 
 
3431 rajveer 7343 
  def validate(self):
7344 
    return
7345 
 
7346 
 
581 rajveer 7347 
  def __repr__(self):
7348 
    L = ['%s=%r' % (key, value)
7349 
      for key, value in self.__dict__.iteritems()]
7350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7351 
 
7352 
  def __eq__(self, other):
7353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7354 
 
7355 
  def __ne__(self, other):
7356 
    return not (self == other)
7357 
 
594 rajveer 7358 
class getAllAddressesForUser_args:
7359 
  """
7360 
  Attributes:
7361 
   - userId
7362 
  """
7363 
 
7364 
  thrift_spec = (
7365 
    None, # 0
7366 
    (1, TType.I64, 'userId', None, None, ), # 1
7367 
  )
7368 
 
7369 
  def __init__(self, userId=None,):
7370 
    self.userId = userId
7371 
 
7372 
  def read(self, iprot):
7373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7375 
      return
7376 
    iprot.readStructBegin()
7377 
    while True:
7378 
      (fname, ftype, fid) = iprot.readFieldBegin()
7379 
      if ftype == TType.STOP:
7380 
        break
7381 
      if fid == 1:
7382 
        if ftype == TType.I64:
7383 
          self.userId = iprot.readI64();
7384 
        else:
7385 
          iprot.skip(ftype)
7386 
      else:
7387 
        iprot.skip(ftype)
7388 
      iprot.readFieldEnd()
7389 
    iprot.readStructEnd()
7390 
 
7391 
  def write(self, oprot):
7392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7394 
      return
7395 
    oprot.writeStructBegin('getAllAddressesForUser_args')
3431 rajveer 7396 
    if self.userId is not None:
594 rajveer 7397 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7398 
      oprot.writeI64(self.userId)
7399 
      oprot.writeFieldEnd()
7400 
    oprot.writeFieldStop()
7401 
    oprot.writeStructEnd()
7402 
 
3431 rajveer 7403 
  def validate(self):
7404 
    return
7405 
 
7406 
 
594 rajveer 7407 
  def __repr__(self):
7408 
    L = ['%s=%r' % (key, value)
7409 
      for key, value in self.__dict__.iteritems()]
7410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7411 
 
7412 
  def __eq__(self, other):
7413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7414 
 
7415 
  def __ne__(self, other):
7416 
    return not (self == other)
7417 
 
7418 
class getAllAddressesForUser_result:
7419 
  """
7420 
  Attributes:
7421 
   - success
7422 
   - ucx
7423 
  """
7424 
 
7425 
  thrift_spec = (
7426 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
7427 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7428 
  )
7429 
 
7430 
  def __init__(self, success=None, ucx=None,):
7431 
    self.success = success
7432 
    self.ucx = ucx
7433 
 
7434 
  def read(self, iprot):
7435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7437 
      return
7438 
    iprot.readStructBegin()
7439 
    while True:
7440 
      (fname, ftype, fid) = iprot.readFieldBegin()
7441 
      if ftype == TType.STOP:
7442 
        break
7443 
      if fid == 0:
7444 
        if ftype == TType.LIST:
7445 
          self.success = []
11592 amit.gupta 7446 
          (_etype100, _size97) = iprot.readListBegin()
7447 
          for _i101 in xrange(_size97):
7448 
            _elem102 = Address()
7449 
            _elem102.read(iprot)
7450 
            self.success.append(_elem102)
594 rajveer 7451 
          iprot.readListEnd()
7452 
        else:
7453 
          iprot.skip(ftype)
7454 
      elif fid == 1:
7455 
        if ftype == TType.STRUCT:
7456 
          self.ucx = UserContextException()
7457 
          self.ucx.read(iprot)
7458 
        else:
7459 
          iprot.skip(ftype)
7460 
      else:
7461 
        iprot.skip(ftype)
7462 
      iprot.readFieldEnd()
7463 
    iprot.readStructEnd()
7464 
 
7465 
  def write(self, oprot):
7466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7468 
      return
7469 
    oprot.writeStructBegin('getAllAddressesForUser_result')
3431 rajveer 7470 
    if self.success is not None:
594 rajveer 7471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 7473 
      for iter103 in self.success:
7474 
        iter103.write(oprot)
594 rajveer 7475 
      oprot.writeListEnd()
7476 
      oprot.writeFieldEnd()
3431 rajveer 7477 
    if self.ucx is not None:
594 rajveer 7478 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7479 
      self.ucx.write(oprot)
7480 
      oprot.writeFieldEnd()
7481 
    oprot.writeFieldStop()
7482 
    oprot.writeStructEnd()
7483 
 
3431 rajveer 7484 
  def validate(self):
7485 
    return
7486 
 
7487 
 
594 rajveer 7488 
  def __repr__(self):
7489 
    L = ['%s=%r' % (key, value)
7490 
      for key, value in self.__dict__.iteritems()]
7491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7492 
 
7493 
  def __eq__(self, other):
7494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7495 
 
7496 
  def __ne__(self, other):
7497 
    return not (self == other)
7498 
 
1894 vikas 7499 
class getAddressById_args:
7500 
  """
7501 
  Attributes:
7502 
   - addressId
7503 
  """
7504 
 
7505 
  thrift_spec = (
7506 
    None, # 0
7507 
    (1, TType.I64, 'addressId', None, None, ), # 1
7508 
  )
7509 
 
7510 
  def __init__(self, addressId=None,):
7511 
    self.addressId = addressId
7512 
 
7513 
  def read(self, iprot):
7514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7516 
      return
7517 
    iprot.readStructBegin()
7518 
    while True:
7519 
      (fname, ftype, fid) = iprot.readFieldBegin()
7520 
      if ftype == TType.STOP:
7521 
        break
7522 
      if fid == 1:
7523 
        if ftype == TType.I64:
7524 
          self.addressId = iprot.readI64();
7525 
        else:
7526 
          iprot.skip(ftype)
7527 
      else:
7528 
        iprot.skip(ftype)
7529 
      iprot.readFieldEnd()
7530 
    iprot.readStructEnd()
7531 
 
7532 
  def write(self, oprot):
7533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7535 
      return
7536 
    oprot.writeStructBegin('getAddressById_args')
3431 rajveer 7537 
    if self.addressId is not None:
1894 vikas 7538 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
7539 
      oprot.writeI64(self.addressId)
7540 
      oprot.writeFieldEnd()
7541 
    oprot.writeFieldStop()
7542 
    oprot.writeStructEnd()
7543 
 
3431 rajveer 7544 
  def validate(self):
7545 
    return
7546 
 
7547 
 
1894 vikas 7548 
  def __repr__(self):
7549 
    L = ['%s=%r' % (key, value)
7550 
      for key, value in self.__dict__.iteritems()]
7551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7552 
 
7553 
  def __eq__(self, other):
7554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7555 
 
7556 
  def __ne__(self, other):
7557 
    return not (self == other)
7558 
 
7559 
class getAddressById_result:
7560 
  """
7561 
  Attributes:
7562 
   - success
7563 
   - ucx
7564 
  """
7565 
 
7566 
  thrift_spec = (
7567 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
7568 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7569 
  )
7570 
 
7571 
  def __init__(self, success=None, ucx=None,):
7572 
    self.success = success
7573 
    self.ucx = ucx
7574 
 
7575 
  def read(self, iprot):
7576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7578 
      return
7579 
    iprot.readStructBegin()
7580 
    while True:
7581 
      (fname, ftype, fid) = iprot.readFieldBegin()
7582 
      if ftype == TType.STOP:
7583 
        break
7584 
      if fid == 0:
7585 
        if ftype == TType.STRUCT:
7586 
          self.success = Address()
7587 
          self.success.read(iprot)
7588 
        else:
7589 
          iprot.skip(ftype)
7590 
      elif fid == 1:
7591 
        if ftype == TType.STRUCT:
7592 
          self.ucx = UserContextException()
7593 
          self.ucx.read(iprot)
7594 
        else:
7595 
          iprot.skip(ftype)
7596 
      else:
7597 
        iprot.skip(ftype)
7598 
      iprot.readFieldEnd()
7599 
    iprot.readStructEnd()
7600 
 
7601 
  def write(self, oprot):
7602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7604 
      return
7605 
    oprot.writeStructBegin('getAddressById_result')
3431 rajveer 7606 
    if self.success is not None:
1894 vikas 7607 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7608 
      self.success.write(oprot)
7609 
      oprot.writeFieldEnd()
3431 rajveer 7610 
    if self.ucx is not None:
1894 vikas 7611 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7612 
      self.ucx.write(oprot)
7613 
      oprot.writeFieldEnd()
7614 
    oprot.writeFieldStop()
7615 
    oprot.writeStructEnd()
7616 
 
3431 rajveer 7617 
  def validate(self):
7618 
    return
7619 
 
7620 
 
1894 vikas 7621 
  def __repr__(self):
7622 
    L = ['%s=%r' % (key, value)
7623 
      for key, value in self.__dict__.iteritems()]
7624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7625 
 
7626 
  def __eq__(self, other):
7627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7628 
 
7629 
  def __ne__(self, other):
7630 
    return not (self == other)
7631 
 
594 rajveer 7632 
class getDefaultAddressId_args:
7633 
  """
7634 
  Attributes:
7635 
   - userId
7636 
  """
7637 
 
7638 
  thrift_spec = (
7639 
    None, # 0
7640 
    (1, TType.I64, 'userId', None, None, ), # 1
7641 
  )
7642 
 
7643 
  def __init__(self, userId=None,):
7644 
    self.userId = userId
7645 
 
7646 
  def read(self, iprot):
7647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7649 
      return
7650 
    iprot.readStructBegin()
7651 
    while True:
7652 
      (fname, ftype, fid) = iprot.readFieldBegin()
7653 
      if ftype == TType.STOP:
7654 
        break
7655 
      if fid == 1:
7656 
        if ftype == TType.I64:
7657 
          self.userId = iprot.readI64();
7658 
        else:
7659 
          iprot.skip(ftype)
7660 
      else:
7661 
        iprot.skip(ftype)
7662 
      iprot.readFieldEnd()
7663 
    iprot.readStructEnd()
7664 
 
7665 
  def write(self, oprot):
7666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7668 
      return
7669 
    oprot.writeStructBegin('getDefaultAddressId_args')
3431 rajveer 7670 
    if self.userId is not None:
594 rajveer 7671 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7672 
      oprot.writeI64(self.userId)
7673 
      oprot.writeFieldEnd()
7674 
    oprot.writeFieldStop()
7675 
    oprot.writeStructEnd()
7676 
 
3431 rajveer 7677 
  def validate(self):
7678 
    return
7679 
 
7680 
 
594 rajveer 7681 
  def __repr__(self):
7682 
    L = ['%s=%r' % (key, value)
7683 
      for key, value in self.__dict__.iteritems()]
7684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7685 
 
7686 
  def __eq__(self, other):
7687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7688 
 
7689 
  def __ne__(self, other):
7690 
    return not (self == other)
7691 
 
7692 
class getDefaultAddressId_result:
7693 
  """
7694 
  Attributes:
7695 
   - success
7696 
   - ucx
7697 
  """
7698 
 
7699 
  thrift_spec = (
7700 
    (0, TType.I64, 'success', None, None, ), # 0
7701 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7702 
  )
7703 
 
7704 
  def __init__(self, success=None, ucx=None,):
7705 
    self.success = success
7706 
    self.ucx = ucx
7707 
 
7708 
  def read(self, iprot):
7709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7711 
      return
7712 
    iprot.readStructBegin()
7713 
    while True:
7714 
      (fname, ftype, fid) = iprot.readFieldBegin()
7715 
      if ftype == TType.STOP:
7716 
        break
7717 
      if fid == 0:
7718 
        if ftype == TType.I64:
7719 
          self.success = iprot.readI64();
7720 
        else:
7721 
          iprot.skip(ftype)
7722 
      elif fid == 1:
7723 
        if ftype == TType.STRUCT:
7724 
          self.ucx = UserContextException()
7725 
          self.ucx.read(iprot)
7726 
        else:
7727 
          iprot.skip(ftype)
7728 
      else:
7729 
        iprot.skip(ftype)
7730 
      iprot.readFieldEnd()
7731 
    iprot.readStructEnd()
7732 
 
7733 
  def write(self, oprot):
7734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7736 
      return
7737 
    oprot.writeStructBegin('getDefaultAddressId_result')
3431 rajveer 7738 
    if self.success is not None:
594 rajveer 7739 
      oprot.writeFieldBegin('success', TType.I64, 0)
7740 
      oprot.writeI64(self.success)
7741 
      oprot.writeFieldEnd()
3431 rajveer 7742 
    if self.ucx is not None:
594 rajveer 7743 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7744 
      self.ucx.write(oprot)
7745 
      oprot.writeFieldEnd()
7746 
    oprot.writeFieldStop()
7747 
    oprot.writeStructEnd()
7748 
 
3431 rajveer 7749 
  def validate(self):
7750 
    return
7751 
 
7752 
 
594 rajveer 7753 
  def __repr__(self):
7754 
    L = ['%s=%r' % (key, value)
7755 
      for key, value in self.__dict__.iteritems()]
7756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7757 
 
7758 
  def __eq__(self, other):
7759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7760 
 
7761 
  def __ne__(self, other):
7762 
    return not (self == other)
7763 
 
785 rajveer 7764 
class getDefaultPincode_args:
7765 
  """
7766 
  Attributes:
7767 
   - userId
7768 
  """
7769 
 
7770 
  thrift_spec = (
7771 
    None, # 0
7772 
    (1, TType.I64, 'userId', None, None, ), # 1
7773 
  )
7774 
 
7775 
  def __init__(self, userId=None,):
7776 
    self.userId = userId
7777 
 
7778 
  def read(self, iprot):
7779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7781 
      return
7782 
    iprot.readStructBegin()
7783 
    while True:
7784 
      (fname, ftype, fid) = iprot.readFieldBegin()
7785 
      if ftype == TType.STOP:
7786 
        break
7787 
      if fid == 1:
7788 
        if ftype == TType.I64:
7789 
          self.userId = iprot.readI64();
7790 
        else:
7791 
          iprot.skip(ftype)
7792 
      else:
7793 
        iprot.skip(ftype)
7794 
      iprot.readFieldEnd()
7795 
    iprot.readStructEnd()
7796 
 
7797 
  def write(self, oprot):
7798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7800 
      return
7801 
    oprot.writeStructBegin('getDefaultPincode_args')
3431 rajveer 7802 
    if self.userId is not None:
785 rajveer 7803 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7804 
      oprot.writeI64(self.userId)
7805 
      oprot.writeFieldEnd()
7806 
    oprot.writeFieldStop()
7807 
    oprot.writeStructEnd()
7808 
 
3431 rajveer 7809 
  def validate(self):
7810 
    return
7811 
 
7812 
 
785 rajveer 7813 
  def __repr__(self):
7814 
    L = ['%s=%r' % (key, value)
7815 
      for key, value in self.__dict__.iteritems()]
7816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7817 
 
7818 
  def __eq__(self, other):
7819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7820 
 
7821 
  def __ne__(self, other):
7822 
    return not (self == other)
7823 
 
7824 
class getDefaultPincode_result:
7825 
  """
7826 
  Attributes:
7827 
   - success
7828 
   - ucx
7829 
  """
7830 
 
7831 
  thrift_spec = (
7832 
    (0, TType.STRING, 'success', None, None, ), # 0
7833 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
7834 
  )
7835 
 
7836 
  def __init__(self, success=None, ucx=None,):
7837 
    self.success = success
7838 
    self.ucx = ucx
7839 
 
7840 
  def read(self, iprot):
7841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7843 
      return
7844 
    iprot.readStructBegin()
7845 
    while True:
7846 
      (fname, ftype, fid) = iprot.readFieldBegin()
7847 
      if ftype == TType.STOP:
7848 
        break
7849 
      if fid == 0:
7850 
        if ftype == TType.STRING:
7851 
          self.success = iprot.readString();
7852 
        else:
7853 
          iprot.skip(ftype)
7854 
      elif fid == 1:
7855 
        if ftype == TType.STRUCT:
7856 
          self.ucx = UserContextException()
7857 
          self.ucx.read(iprot)
7858 
        else:
7859 
          iprot.skip(ftype)
7860 
      else:
7861 
        iprot.skip(ftype)
7862 
      iprot.readFieldEnd()
7863 
    iprot.readStructEnd()
7864 
 
7865 
  def write(self, oprot):
7866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7868 
      return
7869 
    oprot.writeStructBegin('getDefaultPincode_result')
3431 rajveer 7870 
    if self.success is not None:
785 rajveer 7871 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7872 
      oprot.writeString(self.success)
7873 
      oprot.writeFieldEnd()
3431 rajveer 7874 
    if self.ucx is not None:
785 rajveer 7875 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7876 
      self.ucx.write(oprot)
7877 
      oprot.writeFieldEnd()
7878 
    oprot.writeFieldStop()
7879 
    oprot.writeStructEnd()
7880 
 
3431 rajveer 7881 
  def validate(self):
7882 
    return
7883 
 
7884 
 
785 rajveer 7885 
  def __repr__(self):
7886 
    L = ['%s=%r' % (key, value)
7887 
      for key, value in self.__dict__.iteritems()]
7888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7889 
 
7890 
  def __eq__(self, other):
7891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7892 
 
7893 
  def __ne__(self, other):
7894 
    return not (self == other)
7895 
 
1274 varun.gupt 7896 
class saveUserCommunication_args:
7897 
  """
7898 
  Attributes:
7899 
   - userId
7900 
   - replyTo
7901 
   - communicationType
7902 
   - orderId
7903 
   - airwaybillNo
7904 
   - productName
7905 
   - subject
7906 
   - message
7907 
  """
7908 
 
7909 
  thrift_spec = (
7910 
    None, # 0
7911 
    (1, TType.I64, 'userId', None, None, ), # 1
7912 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
7913 
    (3, TType.I64, 'communicationType', None, None, ), # 3
7914 
    (4, TType.I64, 'orderId', None, None, ), # 4
7915 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
7916 
    (6, TType.STRING, 'productName', None, None, ), # 6
7917 
    (7, TType.STRING, 'subject', None, None, ), # 7
7918 
    (8, TType.STRING, 'message', None, None, ), # 8
7919 
  )
7920 
 
7921 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
7922 
    self.userId = userId
7923 
    self.replyTo = replyTo
7924 
    self.communicationType = communicationType
7925 
    self.orderId = orderId
7926 
    self.airwaybillNo = airwaybillNo
7927 
    self.productName = productName
7928 
    self.subject = subject
7929 
    self.message = message
7930 
 
7931 
  def read(self, iprot):
7932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7934 
      return
7935 
    iprot.readStructBegin()
7936 
    while True:
7937 
      (fname, ftype, fid) = iprot.readFieldBegin()
7938 
      if ftype == TType.STOP:
7939 
        break
7940 
      if fid == 1:
7941 
        if ftype == TType.I64:
7942 
          self.userId = iprot.readI64();
7943 
        else:
7944 
          iprot.skip(ftype)
7945 
      elif fid == 2:
7946 
        if ftype == TType.STRING:
7947 
          self.replyTo = iprot.readString();
7948 
        else:
7949 
          iprot.skip(ftype)
7950 
      elif fid == 3:
7951 
        if ftype == TType.I64:
7952 
          self.communicationType = iprot.readI64();
7953 
        else:
7954 
          iprot.skip(ftype)
7955 
      elif fid == 4:
7956 
        if ftype == TType.I64:
7957 
          self.orderId = iprot.readI64();
7958 
        else:
7959 
          iprot.skip(ftype)
7960 
      elif fid == 5:
7961 
        if ftype == TType.STRING:
7962 
          self.airwaybillNo = iprot.readString();
7963 
        else:
7964 
          iprot.skip(ftype)
7965 
      elif fid == 6:
7966 
        if ftype == TType.STRING:
7967 
          self.productName = iprot.readString();
7968 
        else:
7969 
          iprot.skip(ftype)
7970 
      elif fid == 7:
7971 
        if ftype == TType.STRING:
7972 
          self.subject = iprot.readString();
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      elif fid == 8:
7976 
        if ftype == TType.STRING:
7977 
          self.message = iprot.readString();
7978 
        else:
7979 
          iprot.skip(ftype)
7980 
      else:
7981 
        iprot.skip(ftype)
7982 
      iprot.readFieldEnd()
7983 
    iprot.readStructEnd()
7984 
 
7985 
  def write(self, oprot):
7986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7988 
      return
7989 
    oprot.writeStructBegin('saveUserCommunication_args')
3431 rajveer 7990 
    if self.userId is not None:
1274 varun.gupt 7991 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7992 
      oprot.writeI64(self.userId)
7993 
      oprot.writeFieldEnd()
3431 rajveer 7994 
    if self.replyTo is not None:
1274 varun.gupt 7995 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
7996 
      oprot.writeString(self.replyTo)
7997 
      oprot.writeFieldEnd()
3431 rajveer 7998 
    if self.communicationType is not None:
1274 varun.gupt 7999 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
8000 
      oprot.writeI64(self.communicationType)
8001 
      oprot.writeFieldEnd()
3431 rajveer 8002 
    if self.orderId is not None:
1274 varun.gupt 8003 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8004 
      oprot.writeI64(self.orderId)
8005 
      oprot.writeFieldEnd()
3431 rajveer 8006 
    if self.airwaybillNo is not None:
1274 varun.gupt 8007 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
8008 
      oprot.writeString(self.airwaybillNo)
8009 
      oprot.writeFieldEnd()
3431 rajveer 8010 
    if self.productName is not None:
1274 varun.gupt 8011 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
8012 
      oprot.writeString(self.productName)
8013 
      oprot.writeFieldEnd()
3431 rajveer 8014 
    if self.subject is not None:
1274 varun.gupt 8015 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
8016 
      oprot.writeString(self.subject)
8017 
      oprot.writeFieldEnd()
3431 rajveer 8018 
    if self.message is not None:
1274 varun.gupt 8019 
      oprot.writeFieldBegin('message', TType.STRING, 8)
8020 
      oprot.writeString(self.message)
8021 
      oprot.writeFieldEnd()
8022 
    oprot.writeFieldStop()
8023 
    oprot.writeStructEnd()
8024 
 
3431 rajveer 8025 
  def validate(self):
8026 
    return
8027 
 
8028 
 
1274 varun.gupt 8029 
  def __repr__(self):
8030 
    L = ['%s=%r' % (key, value)
8031 
      for key, value in self.__dict__.iteritems()]
8032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8033 
 
8034 
  def __eq__(self, other):
8035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8036 
 
8037 
  def __ne__(self, other):
8038 
    return not (self == other)
8039 
 
8040 
class saveUserCommunication_result:
8041 
  """
8042 
  Attributes:
8043 
   - success
8044 
   - ucx
8045 
  """
8046 
 
8047 
  thrift_spec = (
8048 
    (0, TType.BOOL, 'success', None, None, ), # 0
8049 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8050 
  )
8051 
 
8052 
  def __init__(self, success=None, ucx=None,):
8053 
    self.success = success
8054 
    self.ucx = ucx
8055 
 
8056 
  def read(self, iprot):
8057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8059 
      return
8060 
    iprot.readStructBegin()
8061 
    while True:
8062 
      (fname, ftype, fid) = iprot.readFieldBegin()
8063 
      if ftype == TType.STOP:
8064 
        break
8065 
      if fid == 0:
8066 
        if ftype == TType.BOOL:
8067 
          self.success = iprot.readBool();
8068 
        else:
8069 
          iprot.skip(ftype)
8070 
      elif fid == 1:
8071 
        if ftype == TType.STRUCT:
8072 
          self.ucx = UserCommunicationException()
8073 
          self.ucx.read(iprot)
8074 
        else:
8075 
          iprot.skip(ftype)
8076 
      else:
8077 
        iprot.skip(ftype)
8078 
      iprot.readFieldEnd()
8079 
    iprot.readStructEnd()
8080 
 
8081 
  def write(self, oprot):
8082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8084 
      return
8085 
    oprot.writeStructBegin('saveUserCommunication_result')
3431 rajveer 8086 
    if self.success is not None:
1274 varun.gupt 8087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8088 
      oprot.writeBool(self.success)
8089 
      oprot.writeFieldEnd()
3431 rajveer 8090 
    if self.ucx is not None:
1274 varun.gupt 8091 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8092 
      self.ucx.write(oprot)
8093 
      oprot.writeFieldEnd()
8094 
    oprot.writeFieldStop()
8095 
    oprot.writeStructEnd()
8096 
 
3431 rajveer 8097 
  def validate(self):
8098 
    return
8099 
 
8100 
 
1274 varun.gupt 8101 
  def __repr__(self):
8102 
    L = ['%s=%r' % (key, value)
8103 
      for key, value in self.__dict__.iteritems()]
8104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8105 
 
8106 
  def __eq__(self, other):
8107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8108 
 
8109 
  def __ne__(self, other):
8110 
    return not (self == other)
8111 
 
1590 varun.gupt 8112 
class getUserCommunicationById_args:
8113 
  """
8114 
  Attributes:
8115 
   - id
8116 
  """
8117 
 
8118 
  thrift_spec = (
8119 
    None, # 0
8120 
    (1, TType.I64, 'id', None, None, ), # 1
8121 
  )
8122 
 
8123 
  def __init__(self, id=None,):
8124 
    self.id = id
8125 
 
8126 
  def read(self, iprot):
8127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8129 
      return
8130 
    iprot.readStructBegin()
8131 
    while True:
8132 
      (fname, ftype, fid) = iprot.readFieldBegin()
8133 
      if ftype == TType.STOP:
8134 
        break
8135 
      if fid == 1:
8136 
        if ftype == TType.I64:
8137 
          self.id = iprot.readI64();
8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      else:
8141 
        iprot.skip(ftype)
8142 
      iprot.readFieldEnd()
8143 
    iprot.readStructEnd()
8144 
 
8145 
  def write(self, oprot):
8146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8148 
      return
8149 
    oprot.writeStructBegin('getUserCommunicationById_args')
3431 rajveer 8150 
    if self.id is not None:
1590 varun.gupt 8151 
      oprot.writeFieldBegin('id', TType.I64, 1)
8152 
      oprot.writeI64(self.id)
8153 
      oprot.writeFieldEnd()
8154 
    oprot.writeFieldStop()
8155 
    oprot.writeStructEnd()
8156 
 
3431 rajveer 8157 
  def validate(self):
8158 
    return
8159 
 
8160 
 
1590 varun.gupt 8161 
  def __repr__(self):
8162 
    L = ['%s=%r' % (key, value)
8163 
      for key, value in self.__dict__.iteritems()]
8164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8165 
 
8166 
  def __eq__(self, other):
8167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8168 
 
8169 
  def __ne__(self, other):
8170 
    return not (self == other)
8171 
 
8172 
class getUserCommunicationById_result:
8173 
  """
8174 
  Attributes:
8175 
   - success
8176 
   - ucx
8177 
  """
8178 
 
8179 
  thrift_spec = (
8180 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
8181 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8182 
  )
8183 
 
8184 
  def __init__(self, success=None, ucx=None,):
8185 
    self.success = success
8186 
    self.ucx = ucx
8187 
 
8188 
  def read(self, iprot):
8189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8191 
      return
8192 
    iprot.readStructBegin()
8193 
    while True:
8194 
      (fname, ftype, fid) = iprot.readFieldBegin()
8195 
      if ftype == TType.STOP:
8196 
        break
8197 
      if fid == 0:
8198 
        if ftype == TType.STRUCT:
8199 
          self.success = UserCommunication()
8200 
          self.success.read(iprot)
8201 
        else:
8202 
          iprot.skip(ftype)
8203 
      elif fid == 1:
8204 
        if ftype == TType.STRUCT:
8205 
          self.ucx = UserCommunicationException()
8206 
          self.ucx.read(iprot)
8207 
        else:
8208 
          iprot.skip(ftype)
8209 
      else:
8210 
        iprot.skip(ftype)
8211 
      iprot.readFieldEnd()
8212 
    iprot.readStructEnd()
8213 
 
8214 
  def write(self, oprot):
8215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8217 
      return
8218 
    oprot.writeStructBegin('getUserCommunicationById_result')
3431 rajveer 8219 
    if self.success is not None:
1590 varun.gupt 8220 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8221 
      self.success.write(oprot)
8222 
      oprot.writeFieldEnd()
3431 rajveer 8223 
    if self.ucx is not None:
1590 varun.gupt 8224 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8225 
      self.ucx.write(oprot)
8226 
      oprot.writeFieldEnd()
8227 
    oprot.writeFieldStop()
8228 
    oprot.writeStructEnd()
8229 
 
3431 rajveer 8230 
  def validate(self):
8231 
    return
8232 
 
8233 
 
1590 varun.gupt 8234 
  def __repr__(self):
8235 
    L = ['%s=%r' % (key, value)
8236 
      for key, value in self.__dict__.iteritems()]
8237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8238 
 
8239 
  def __eq__(self, other):
8240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8241 
 
8242 
  def __ne__(self, other):
8243 
    return not (self == other)
8244 
 
8245 
class getUserCommunicationByUser_args:
8246 
  """
8247 
  Attributes:
8248 
   - userId
8249 
  """
8250 
 
8251 
  thrift_spec = (
8252 
    None, # 0
8253 
    (1, TType.I64, 'userId', None, None, ), # 1
8254 
  )
8255 
 
8256 
  def __init__(self, userId=None,):
8257 
    self.userId = userId
8258 
 
8259 
  def read(self, iprot):
8260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8262 
      return
8263 
    iprot.readStructBegin()
8264 
    while True:
8265 
      (fname, ftype, fid) = iprot.readFieldBegin()
8266 
      if ftype == TType.STOP:
8267 
        break
8268 
      if fid == 1:
8269 
        if ftype == TType.I64:
8270 
          self.userId = iprot.readI64();
8271 
        else:
8272 
          iprot.skip(ftype)
8273 
      else:
8274 
        iprot.skip(ftype)
8275 
      iprot.readFieldEnd()
8276 
    iprot.readStructEnd()
8277 
 
8278 
  def write(self, oprot):
8279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8281 
      return
8282 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
3431 rajveer 8283 
    if self.userId is not None:
1590 varun.gupt 8284 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8285 
      oprot.writeI64(self.userId)
8286 
      oprot.writeFieldEnd()
8287 
    oprot.writeFieldStop()
8288 
    oprot.writeStructEnd()
8289 
 
3431 rajveer 8290 
  def validate(self):
8291 
    return
8292 
 
8293 
 
1590 varun.gupt 8294 
  def __repr__(self):
8295 
    L = ['%s=%r' % (key, value)
8296 
      for key, value in self.__dict__.iteritems()]
8297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8298 
 
8299 
  def __eq__(self, other):
8300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8301 
 
8302 
  def __ne__(self, other):
8303 
    return not (self == other)
8304 
 
8305 
class getUserCommunicationByUser_result:
8306 
  """
8307 
  Attributes:
8308 
   - success
8309 
   - ucx
8310 
  """
8311 
 
8312 
  thrift_spec = (
8313 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8314 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8315 
  )
8316 
 
8317 
  def __init__(self, success=None, ucx=None,):
8318 
    self.success = success
8319 
    self.ucx = ucx
8320 
 
8321 
  def read(self, iprot):
8322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8324 
      return
8325 
    iprot.readStructBegin()
8326 
    while True:
8327 
      (fname, ftype, fid) = iprot.readFieldBegin()
8328 
      if ftype == TType.STOP:
8329 
        break
8330 
      if fid == 0:
8331 
        if ftype == TType.LIST:
8332 
          self.success = []
11592 amit.gupta 8333 
          (_etype107, _size104) = iprot.readListBegin()
8334 
          for _i108 in xrange(_size104):
8335 
            _elem109 = UserCommunication()
8336 
            _elem109.read(iprot)
8337 
            self.success.append(_elem109)
1590 varun.gupt 8338 
          iprot.readListEnd()
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      elif fid == 1:
8342 
        if ftype == TType.STRUCT:
8343 
          self.ucx = UserCommunicationException()
8344 
          self.ucx.read(iprot)
8345 
        else:
8346 
          iprot.skip(ftype)
8347 
      else:
8348 
        iprot.skip(ftype)
8349 
      iprot.readFieldEnd()
8350 
    iprot.readStructEnd()
8351 
 
8352 
  def write(self, oprot):
8353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8355 
      return
8356 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
3431 rajveer 8357 
    if self.success is not None:
1590 varun.gupt 8358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8360 
      for iter110 in self.success:
8361 
        iter110.write(oprot)
1590 varun.gupt 8362 
      oprot.writeListEnd()
8363 
      oprot.writeFieldEnd()
3431 rajveer 8364 
    if self.ucx is not None:
1590 varun.gupt 8365 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8366 
      self.ucx.write(oprot)
8367 
      oprot.writeFieldEnd()
8368 
    oprot.writeFieldStop()
8369 
    oprot.writeStructEnd()
8370 
 
3431 rajveer 8371 
  def validate(self):
8372 
    return
8373 
 
8374 
 
1590 varun.gupt 8375 
  def __repr__(self):
8376 
    L = ['%s=%r' % (key, value)
8377 
      for key, value in self.__dict__.iteritems()]
8378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8379 
 
8380 
  def __eq__(self, other):
8381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8382 
 
8383 
  def __ne__(self, other):
8384 
    return not (self == other)
8385 
 
8386 
class getAllUserCommunications_args:
8387 
 
8388 
  thrift_spec = (
8389 
  )
8390 
 
8391 
  def read(self, iprot):
8392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8394 
      return
8395 
    iprot.readStructBegin()
8396 
    while True:
8397 
      (fname, ftype, fid) = iprot.readFieldBegin()
8398 
      if ftype == TType.STOP:
8399 
        break
8400 
      else:
8401 
        iprot.skip(ftype)
8402 
      iprot.readFieldEnd()
8403 
    iprot.readStructEnd()
8404 
 
8405 
  def write(self, oprot):
8406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8408 
      return
8409 
    oprot.writeStructBegin('getAllUserCommunications_args')
8410 
    oprot.writeFieldStop()
8411 
    oprot.writeStructEnd()
8412 
 
3431 rajveer 8413 
  def validate(self):
8414 
    return
8415 
 
8416 
 
1590 varun.gupt 8417 
  def __repr__(self):
8418 
    L = ['%s=%r' % (key, value)
8419 
      for key, value in self.__dict__.iteritems()]
8420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8421 
 
8422 
  def __eq__(self, other):
8423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8424 
 
8425 
  def __ne__(self, other):
8426 
    return not (self == other)
8427 
 
8428 
class getAllUserCommunications_result:
8429 
  """
8430 
  Attributes:
8431 
   - success
8432 
   - ucx
8433 
  """
8434 
 
8435 
  thrift_spec = (
8436 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
8437 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8438 
  )
8439 
 
8440 
  def __init__(self, success=None, ucx=None,):
8441 
    self.success = success
8442 
    self.ucx = ucx
8443 
 
8444 
  def read(self, iprot):
8445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8447 
      return
8448 
    iprot.readStructBegin()
8449 
    while True:
8450 
      (fname, ftype, fid) = iprot.readFieldBegin()
8451 
      if ftype == TType.STOP:
8452 
        break
8453 
      if fid == 0:
8454 
        if ftype == TType.LIST:
8455 
          self.success = []
11592 amit.gupta 8456 
          (_etype114, _size111) = iprot.readListBegin()
8457 
          for _i115 in xrange(_size111):
8458 
            _elem116 = UserCommunication()
8459 
            _elem116.read(iprot)
8460 
            self.success.append(_elem116)
1590 varun.gupt 8461 
          iprot.readListEnd()
8462 
        else:
8463 
          iprot.skip(ftype)
8464 
      elif fid == 1:
8465 
        if ftype == TType.STRUCT:
8466 
          self.ucx = UserCommunicationException()
8467 
          self.ucx.read(iprot)
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      else:
8471 
        iprot.skip(ftype)
8472 
      iprot.readFieldEnd()
8473 
    iprot.readStructEnd()
8474 
 
8475 
  def write(self, oprot):
8476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8478 
      return
8479 
    oprot.writeStructBegin('getAllUserCommunications_result')
3431 rajveer 8480 
    if self.success is not None:
1590 varun.gupt 8481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8483 
      for iter117 in self.success:
8484 
        iter117.write(oprot)
1590 varun.gupt 8485 
      oprot.writeListEnd()
8486 
      oprot.writeFieldEnd()
3431 rajveer 8487 
    if self.ucx is not None:
1590 varun.gupt 8488 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8489 
      self.ucx.write(oprot)
8490 
      oprot.writeFieldEnd()
8491 
    oprot.writeFieldStop()
8492 
    oprot.writeStructEnd()
8493 
 
3431 rajveer 8494 
  def validate(self):
8495 
    return
8496 
 
8497 
 
1590 varun.gupt 8498 
  def __repr__(self):
8499 
    L = ['%s=%r' % (key, value)
8500 
      for key, value in self.__dict__.iteritems()]
8501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8502 
 
8503 
  def __eq__(self, other):
8504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8505 
 
8506 
  def __ne__(self, other):
8507 
    return not (self == other)
8508 
 
5407 amar.kumar 8509 
class removeUserCommunication_args:
8510 
  """
8511 
  Attributes:
8512 
   - id
8513 
  """
8514 
 
8515 
  thrift_spec = (
8516 
    None, # 0
8517 
    (1, TType.I64, 'id', None, None, ), # 1
8518 
  )
8519 
 
8520 
  def __init__(self, id=None,):
8521 
    self.id = id
8522 
 
8523 
  def read(self, iprot):
8524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8526 
      return
8527 
    iprot.readStructBegin()
8528 
    while True:
8529 
      (fname, ftype, fid) = iprot.readFieldBegin()
8530 
      if ftype == TType.STOP:
8531 
        break
8532 
      if fid == 1:
8533 
        if ftype == TType.I64:
8534 
          self.id = iprot.readI64();
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      else:
8538 
        iprot.skip(ftype)
8539 
      iprot.readFieldEnd()
8540 
    iprot.readStructEnd()
8541 
 
8542 
  def write(self, oprot):
8543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8545 
      return
8546 
    oprot.writeStructBegin('removeUserCommunication_args')
8547 
    if self.id is not None:
8548 
      oprot.writeFieldBegin('id', TType.I64, 1)
8549 
      oprot.writeI64(self.id)
8550 
      oprot.writeFieldEnd()
8551 
    oprot.writeFieldStop()
8552 
    oprot.writeStructEnd()
8553 
 
8554 
  def validate(self):
8555 
    return
8556 
 
8557 
 
8558 
  def __repr__(self):
8559 
    L = ['%s=%r' % (key, value)
8560 
      for key, value in self.__dict__.iteritems()]
8561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8562 
 
8563 
  def __eq__(self, other):
8564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8565 
 
8566 
  def __ne__(self, other):
8567 
    return not (self == other)
8568 
 
8569 
class removeUserCommunication_result:
8570 
  """
8571 
  Attributes:
8572 
   - ucx
8573 
  """
8574 
 
8575 
  thrift_spec = (
8576 
    None, # 0
8577 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
8578 
  )
8579 
 
8580 
  def __init__(self, ucx=None,):
8581 
    self.ucx = ucx
8582 
 
8583 
  def read(self, iprot):
8584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8586 
      return
8587 
    iprot.readStructBegin()
8588 
    while True:
8589 
      (fname, ftype, fid) = iprot.readFieldBegin()
8590 
      if ftype == TType.STOP:
8591 
        break
8592 
      if fid == 1:
8593 
        if ftype == TType.STRUCT:
8594 
          self.ucx = UserCommunicationException()
8595 
          self.ucx.read(iprot)
8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      else:
8599 
        iprot.skip(ftype)
8600 
      iprot.readFieldEnd()
8601 
    iprot.readStructEnd()
8602 
 
8603 
  def write(self, oprot):
8604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8606 
      return
8607 
    oprot.writeStructBegin('removeUserCommunication_result')
8608 
    if self.ucx is not None:
8609 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
8610 
      self.ucx.write(oprot)
8611 
      oprot.writeFieldEnd()
8612 
    oprot.writeFieldStop()
8613 
    oprot.writeStructEnd()
8614 
 
8615 
  def validate(self):
8616 
    return
8617 
 
8618 
 
8619 
  def __repr__(self):
8620 
    L = ['%s=%r' % (key, value)
8621 
      for key, value in self.__dict__.iteritems()]
8622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8623 
 
8624 
  def __eq__(self, other):
8625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8626 
 
8627 
  def __ne__(self, other):
8628 
    return not (self == other)
8629 
 
1845 vikas 8630 
class createMasterAffiliate_args:
8631 
  """
8632 
  Attributes:
8633 
   - name
1859 vikas 8634 
   - addedOn
1845 vikas 8635 
  """
8636 
 
8637 
  thrift_spec = (
8638 
    None, # 0
8639 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 8640 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8641 
  )
8642 
 
1859 vikas 8643 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 8644 
    self.name = name
1859 vikas 8645 
    self.addedOn = addedOn
1845 vikas 8646 
 
8647 
  def read(self, iprot):
8648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8650 
      return
8651 
    iprot.readStructBegin()
8652 
    while True:
8653 
      (fname, ftype, fid) = iprot.readFieldBegin()
8654 
      if ftype == TType.STOP:
8655 
        break
8656 
      if fid == 1:
8657 
        if ftype == TType.STRING:
8658 
          self.name = iprot.readString();
8659 
        else:
8660 
          iprot.skip(ftype)
1859 vikas 8661 
      elif fid == 2:
8662 
        if ftype == TType.I64:
8663 
          self.addedOn = iprot.readI64();
8664 
        else:
8665 
          iprot.skip(ftype)
1845 vikas 8666 
      else:
8667 
        iprot.skip(ftype)
8668 
      iprot.readFieldEnd()
8669 
    iprot.readStructEnd()
8670 
 
8671 
  def write(self, oprot):
8672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8674 
      return
8675 
    oprot.writeStructBegin('createMasterAffiliate_args')
3431 rajveer 8676 
    if self.name is not None:
1845 vikas 8677 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8678 
      oprot.writeString(self.name)
8679 
      oprot.writeFieldEnd()
3431 rajveer 8680 
    if self.addedOn is not None:
1859 vikas 8681 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8682 
      oprot.writeI64(self.addedOn)
8683 
      oprot.writeFieldEnd()
1845 vikas 8684 
    oprot.writeFieldStop()
8685 
    oprot.writeStructEnd()
8686 
 
3431 rajveer 8687 
  def validate(self):
8688 
    return
8689 
 
8690 
 
1845 vikas 8691 
  def __repr__(self):
8692 
    L = ['%s=%r' % (key, value)
8693 
      for key, value in self.__dict__.iteritems()]
8694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8695 
 
8696 
  def __eq__(self, other):
8697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8698 
 
8699 
  def __ne__(self, other):
8700 
    return not (self == other)
8701 
 
8702 
class createMasterAffiliate_result:
8703 
  """
8704 
  Attributes:
8705 
   - success
8706 
   - utx
8707 
  """
8708 
 
8709 
  thrift_spec = (
8710 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8711 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8712 
  )
8713 
 
8714 
  def __init__(self, success=None, utx=None,):
8715 
    self.success = success
8716 
    self.utx = utx
8717 
 
8718 
  def read(self, iprot):
8719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8721 
      return
8722 
    iprot.readStructBegin()
8723 
    while True:
8724 
      (fname, ftype, fid) = iprot.readFieldBegin()
8725 
      if ftype == TType.STOP:
8726 
        break
8727 
      if fid == 0:
8728 
        if ftype == TType.STRUCT:
8729 
          self.success = MasterAffiliate()
8730 
          self.success.read(iprot)
8731 
        else:
8732 
          iprot.skip(ftype)
8733 
      elif fid == 1:
8734 
        if ftype == TType.STRUCT:
1996 vikas 8735 
          self.utx = UserAffiliateException()
1845 vikas 8736 
          self.utx.read(iprot)
8737 
        else:
8738 
          iprot.skip(ftype)
8739 
      else:
8740 
        iprot.skip(ftype)
8741 
      iprot.readFieldEnd()
8742 
    iprot.readStructEnd()
8743 
 
8744 
  def write(self, oprot):
8745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8747 
      return
8748 
    oprot.writeStructBegin('createMasterAffiliate_result')
3431 rajveer 8749 
    if self.success is not None:
1845 vikas 8750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8751 
      self.success.write(oprot)
8752 
      oprot.writeFieldEnd()
3431 rajveer 8753 
    if self.utx is not None:
1845 vikas 8754 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8755 
      self.utx.write(oprot)
8756 
      oprot.writeFieldEnd()
8757 
    oprot.writeFieldStop()
8758 
    oprot.writeStructEnd()
8759 
 
3431 rajveer 8760 
  def validate(self):
8761 
    return
8762 
 
8763 
 
1845 vikas 8764 
  def __repr__(self):
8765 
    L = ['%s=%r' % (key, value)
8766 
      for key, value in self.__dict__.iteritems()]
8767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8768 
 
8769 
  def __eq__(self, other):
8770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8771 
 
8772 
  def __ne__(self, other):
8773 
    return not (self == other)
8774 
 
1899 vikas 8775 
class getAllMasterAffiliates_args:
8776 
 
8777 
  thrift_spec = (
8778 
  )
8779 
 
8780 
  def read(self, iprot):
8781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8783 
      return
8784 
    iprot.readStructBegin()
8785 
    while True:
8786 
      (fname, ftype, fid) = iprot.readFieldBegin()
8787 
      if ftype == TType.STOP:
8788 
        break
8789 
      else:
8790 
        iprot.skip(ftype)
8791 
      iprot.readFieldEnd()
8792 
    iprot.readStructEnd()
8793 
 
8794 
  def write(self, oprot):
8795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8797 
      return
8798 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
8799 
    oprot.writeFieldStop()
8800 
    oprot.writeStructEnd()
8801 
 
3431 rajveer 8802 
  def validate(self):
8803 
    return
8804 
 
8805 
 
1899 vikas 8806 
  def __repr__(self):
8807 
    L = ['%s=%r' % (key, value)
8808 
      for key, value in self.__dict__.iteritems()]
8809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8810 
 
8811 
  def __eq__(self, other):
8812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8813 
 
8814 
  def __ne__(self, other):
8815 
    return not (self == other)
8816 
 
8817 
class getAllMasterAffiliates_result:
8818 
  """
8819 
  Attributes:
8820 
   - success
8821 
   - utx
8822 
  """
8823 
 
8824 
  thrift_spec = (
8825 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 8826 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 8827 
  )
8828 
 
8829 
  def __init__(self, success=None, utx=None,):
8830 
    self.success = success
8831 
    self.utx = utx
8832 
 
8833 
  def read(self, iprot):
8834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8836 
      return
8837 
    iprot.readStructBegin()
8838 
    while True:
8839 
      (fname, ftype, fid) = iprot.readFieldBegin()
8840 
      if ftype == TType.STOP:
8841 
        break
8842 
      if fid == 0:
8843 
        if ftype == TType.LIST:
8844 
          self.success = []
11592 amit.gupta 8845 
          (_etype121, _size118) = iprot.readListBegin()
8846 
          for _i122 in xrange(_size118):
8847 
            _elem123 = MasterAffiliate()
8848 
            _elem123.read(iprot)
8849 
            self.success.append(_elem123)
1899 vikas 8850 
          iprot.readListEnd()
8851 
        else:
8852 
          iprot.skip(ftype)
8853 
      elif fid == 1:
8854 
        if ftype == TType.STRUCT:
1996 vikas 8855 
          self.utx = UserAffiliateException()
1899 vikas 8856 
          self.utx.read(iprot)
8857 
        else:
8858 
          iprot.skip(ftype)
8859 
      else:
8860 
        iprot.skip(ftype)
8861 
      iprot.readFieldEnd()
8862 
    iprot.readStructEnd()
8863 
 
8864 
  def write(self, oprot):
8865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8867 
      return
8868 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
3431 rajveer 8869 
    if self.success is not None:
1899 vikas 8870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 8872 
      for iter124 in self.success:
8873 
        iter124.write(oprot)
1899 vikas 8874 
      oprot.writeListEnd()
8875 
      oprot.writeFieldEnd()
3431 rajveer 8876 
    if self.utx is not None:
1899 vikas 8877 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8878 
      self.utx.write(oprot)
8879 
      oprot.writeFieldEnd()
8880 
    oprot.writeFieldStop()
8881 
    oprot.writeStructEnd()
8882 
 
3431 rajveer 8883 
  def validate(self):
8884 
    return
8885 
 
8886 
 
1899 vikas 8887 
  def __repr__(self):
8888 
    L = ['%s=%r' % (key, value)
8889 
      for key, value in self.__dict__.iteritems()]
8890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8891 
 
8892 
  def __eq__(self, other):
8893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8894 
 
8895 
  def __ne__(self, other):
8896 
    return not (self == other)
8897 
 
1845 vikas 8898 
class getMasterAffiliateById_args:
8899 
  """
8900 
  Attributes:
8901 
   - id
8902 
  """
8903 
 
8904 
  thrift_spec = (
8905 
    None, # 0
8906 
    (1, TType.I64, 'id', None, None, ), # 1
8907 
  )
8908 
 
8909 
  def __init__(self, id=None,):
8910 
    self.id = id
8911 
 
8912 
  def read(self, iprot):
8913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8915 
      return
8916 
    iprot.readStructBegin()
8917 
    while True:
8918 
      (fname, ftype, fid) = iprot.readFieldBegin()
8919 
      if ftype == TType.STOP:
8920 
        break
8921 
      if fid == 1:
8922 
        if ftype == TType.I64:
8923 
          self.id = iprot.readI64();
8924 
        else:
8925 
          iprot.skip(ftype)
8926 
      else:
8927 
        iprot.skip(ftype)
8928 
      iprot.readFieldEnd()
8929 
    iprot.readStructEnd()
8930 
 
8931 
  def write(self, oprot):
8932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8934 
      return
8935 
    oprot.writeStructBegin('getMasterAffiliateById_args')
3431 rajveer 8936 
    if self.id is not None:
1845 vikas 8937 
      oprot.writeFieldBegin('id', TType.I64, 1)
8938 
      oprot.writeI64(self.id)
8939 
      oprot.writeFieldEnd()
8940 
    oprot.writeFieldStop()
8941 
    oprot.writeStructEnd()
8942 
 
3431 rajveer 8943 
  def validate(self):
8944 
    return
8945 
 
8946 
 
1845 vikas 8947 
  def __repr__(self):
8948 
    L = ['%s=%r' % (key, value)
8949 
      for key, value in self.__dict__.iteritems()]
8950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8951 
 
8952 
  def __eq__(self, other):
8953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8954 
 
8955 
  def __ne__(self, other):
8956 
    return not (self == other)
8957 
 
8958 
class getMasterAffiliateById_result:
8959 
  """
8960 
  Attributes:
8961 
   - success
8962 
   - utx
8963 
  """
8964 
 
8965 
  thrift_spec = (
8966 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 8967 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8968 
  )
8969 
 
8970 
  def __init__(self, success=None, utx=None,):
8971 
    self.success = success
8972 
    self.utx = utx
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 0:
8984 
        if ftype == TType.STRUCT:
8985 
          self.success = MasterAffiliate()
8986 
          self.success.read(iprot)
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      elif fid == 1:
8990 
        if ftype == TType.STRUCT:
1996 vikas 8991 
          self.utx = UserAffiliateException()
1845 vikas 8992 
          self.utx.read(iprot)
8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      else:
8996 
        iprot.skip(ftype)
8997 
      iprot.readFieldEnd()
8998 
    iprot.readStructEnd()
8999 
 
9000 
  def write(self, oprot):
9001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9003 
      return
9004 
    oprot.writeStructBegin('getMasterAffiliateById_result')
3431 rajveer 9005 
    if self.success is not None:
1845 vikas 9006 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9007 
      self.success.write(oprot)
9008 
      oprot.writeFieldEnd()
3431 rajveer 9009 
    if self.utx is not None:
1845 vikas 9010 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9011 
      self.utx.write(oprot)
9012 
      oprot.writeFieldEnd()
9013 
    oprot.writeFieldStop()
9014 
    oprot.writeStructEnd()
9015 
 
3431 rajveer 9016 
  def validate(self):
9017 
    return
9018 
 
9019 
 
1845 vikas 9020 
  def __repr__(self):
9021 
    L = ['%s=%r' % (key, value)
9022 
      for key, value in self.__dict__.iteritems()]
9023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9024 
 
9025 
  def __eq__(self, other):
9026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9027 
 
9028 
  def __ne__(self, other):
9029 
    return not (self == other)
9030 
 
9031 
class getMasterAffiliateByName_args:
9032 
  """
9033 
  Attributes:
9034 
   - name
9035 
  """
9036 
 
9037 
  thrift_spec = (
9038 
    None, # 0
9039 
    (1, TType.STRING, 'name', None, None, ), # 1
9040 
  )
9041 
 
9042 
  def __init__(self, name=None,):
9043 
    self.name = name
9044 
 
9045 
  def read(self, iprot):
9046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9048 
      return
9049 
    iprot.readStructBegin()
9050 
    while True:
9051 
      (fname, ftype, fid) = iprot.readFieldBegin()
9052 
      if ftype == TType.STOP:
9053 
        break
9054 
      if fid == 1:
9055 
        if ftype == TType.STRING:
9056 
          self.name = iprot.readString();
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      else:
9060 
        iprot.skip(ftype)
9061 
      iprot.readFieldEnd()
9062 
    iprot.readStructEnd()
9063 
 
9064 
  def write(self, oprot):
9065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9067 
      return
9068 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
3431 rajveer 9069 
    if self.name is not None:
1845 vikas 9070 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9071 
      oprot.writeString(self.name)
9072 
      oprot.writeFieldEnd()
9073 
    oprot.writeFieldStop()
9074 
    oprot.writeStructEnd()
9075 
 
3431 rajveer 9076 
  def validate(self):
9077 
    return
9078 
 
9079 
 
1845 vikas 9080 
  def __repr__(self):
9081 
    L = ['%s=%r' % (key, value)
9082 
      for key, value in self.__dict__.iteritems()]
9083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9084 
 
9085 
  def __eq__(self, other):
9086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9087 
 
9088 
  def __ne__(self, other):
9089 
    return not (self == other)
9090 
 
9091 
class getMasterAffiliateByName_result:
9092 
  """
9093 
  Attributes:
9094 
   - success
9095 
   - utx
9096 
  """
9097 
 
9098 
  thrift_spec = (
9099 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 9100 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9101 
  )
9102 
 
9103 
  def __init__(self, success=None, utx=None,):
9104 
    self.success = success
9105 
    self.utx = utx
9106 
 
9107 
  def read(self, iprot):
9108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9110 
      return
9111 
    iprot.readStructBegin()
9112 
    while True:
9113 
      (fname, ftype, fid) = iprot.readFieldBegin()
9114 
      if ftype == TType.STOP:
9115 
        break
9116 
      if fid == 0:
9117 
        if ftype == TType.STRUCT:
9118 
          self.success = MasterAffiliate()
9119 
          self.success.read(iprot)
9120 
        else:
9121 
          iprot.skip(ftype)
9122 
      elif fid == 1:
9123 
        if ftype == TType.STRUCT:
1996 vikas 9124 
          self.utx = UserAffiliateException()
1845 vikas 9125 
          self.utx.read(iprot)
9126 
        else:
9127 
          iprot.skip(ftype)
9128 
      else:
9129 
        iprot.skip(ftype)
9130 
      iprot.readFieldEnd()
9131 
    iprot.readStructEnd()
9132 
 
9133 
  def write(self, oprot):
9134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9136 
      return
9137 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
3431 rajveer 9138 
    if self.success is not None:
1845 vikas 9139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9140 
      self.success.write(oprot)
9141 
      oprot.writeFieldEnd()
3431 rajveer 9142 
    if self.utx is not None:
1845 vikas 9143 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9144 
      self.utx.write(oprot)
9145 
      oprot.writeFieldEnd()
9146 
    oprot.writeFieldStop()
9147 
    oprot.writeStructEnd()
9148 
 
3431 rajveer 9149 
  def validate(self):
9150 
    return
9151 
 
9152 
 
1845 vikas 9153 
  def __repr__(self):
9154 
    L = ['%s=%r' % (key, value)
9155 
      for key, value in self.__dict__.iteritems()]
9156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9157 
 
9158 
  def __eq__(self, other):
9159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9160 
 
9161 
  def __ne__(self, other):
9162 
    return not (self == other)
9163 
 
9164 
class createAffiliate_args:
9165 
  """
9166 
  Attributes:
9167 
   - name
9168 
   - url
9169 
   - masterAffiliateId
1859 vikas 9170 
   - addedOn
1845 vikas 9171 
  """
9172 
 
9173 
  thrift_spec = (
9174 
    None, # 0
9175 
    (1, TType.STRING, 'name', None, None, ), # 1
9176 
    (2, TType.STRING, 'url', None, None, ), # 2
9177 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 9178 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 9179 
  )
9180 
 
1859 vikas 9181 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 9182 
    self.name = name
9183 
    self.url = url
9184 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 9185 
    self.addedOn = addedOn
1845 vikas 9186 
 
9187 
  def read(self, iprot):
9188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9190 
      return
9191 
    iprot.readStructBegin()
9192 
    while True:
9193 
      (fname, ftype, fid) = iprot.readFieldBegin()
9194 
      if ftype == TType.STOP:
9195 
        break
9196 
      if fid == 1:
9197 
        if ftype == TType.STRING:
9198 
          self.name = iprot.readString();
9199 
        else:
9200 
          iprot.skip(ftype)
9201 
      elif fid == 2:
9202 
        if ftype == TType.STRING:
9203 
          self.url = iprot.readString();
9204 
        else:
9205 
          iprot.skip(ftype)
9206 
      elif fid == 3:
9207 
        if ftype == TType.I64:
9208 
          self.masterAffiliateId = iprot.readI64();
9209 
        else:
9210 
          iprot.skip(ftype)
1859 vikas 9211 
      elif fid == 4:
9212 
        if ftype == TType.I64:
9213 
          self.addedOn = iprot.readI64();
9214 
        else:
9215 
          iprot.skip(ftype)
1845 vikas 9216 
      else:
9217 
        iprot.skip(ftype)
9218 
      iprot.readFieldEnd()
9219 
    iprot.readStructEnd()
9220 
 
9221 
  def write(self, oprot):
9222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9224 
      return
9225 
    oprot.writeStructBegin('createAffiliate_args')
3431 rajveer 9226 
    if self.name is not None:
1845 vikas 9227 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9228 
      oprot.writeString(self.name)
9229 
      oprot.writeFieldEnd()
3431 rajveer 9230 
    if self.url is not None:
1845 vikas 9231 
      oprot.writeFieldBegin('url', TType.STRING, 2)
9232 
      oprot.writeString(self.url)
9233 
      oprot.writeFieldEnd()
3431 rajveer 9234 
    if self.masterAffiliateId is not None:
1845 vikas 9235 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
9236 
      oprot.writeI64(self.masterAffiliateId)
9237 
      oprot.writeFieldEnd()
3431 rajveer 9238 
    if self.addedOn is not None:
1859 vikas 9239 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
9240 
      oprot.writeI64(self.addedOn)
9241 
      oprot.writeFieldEnd()
1845 vikas 9242 
    oprot.writeFieldStop()
9243 
    oprot.writeStructEnd()
9244 
 
3431 rajveer 9245 
  def validate(self):
9246 
    return
9247 
 
9248 
 
1845 vikas 9249 
  def __repr__(self):
9250 
    L = ['%s=%r' % (key, value)
9251 
      for key, value in self.__dict__.iteritems()]
9252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9253 
 
9254 
  def __eq__(self, other):
9255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9256 
 
9257 
  def __ne__(self, other):
9258 
    return not (self == other)
9259 
 
9260 
class createAffiliate_result:
9261 
  """
9262 
  Attributes:
9263 
   - success
9264 
   - utx
9265 
  """
9266 
 
9267 
  thrift_spec = (
9268 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9269 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9270 
  )
9271 
 
9272 
  def __init__(self, success=None, utx=None,):
9273 
    self.success = success
9274 
    self.utx = utx
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 0:
9286 
        if ftype == TType.STRUCT:
9287 
          self.success = Affiliate()
9288 
          self.success.read(iprot)
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      elif fid == 1:
9292 
        if ftype == TType.STRUCT:
1996 vikas 9293 
          self.utx = UserAffiliateException()
1845 vikas 9294 
          self.utx.read(iprot)
9295 
        else:
9296 
          iprot.skip(ftype)
9297 
      else:
9298 
        iprot.skip(ftype)
9299 
      iprot.readFieldEnd()
9300 
    iprot.readStructEnd()
9301 
 
9302 
  def write(self, oprot):
9303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9305 
      return
9306 
    oprot.writeStructBegin('createAffiliate_result')
3431 rajveer 9307 
    if self.success is not None:
1845 vikas 9308 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9309 
      self.success.write(oprot)
9310 
      oprot.writeFieldEnd()
3431 rajveer 9311 
    if self.utx is not None:
1845 vikas 9312 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9313 
      self.utx.write(oprot)
9314 
      oprot.writeFieldEnd()
9315 
    oprot.writeFieldStop()
9316 
    oprot.writeStructEnd()
9317 
 
3431 rajveer 9318 
  def validate(self):
9319 
    return
9320 
 
9321 
 
1845 vikas 9322 
  def __repr__(self):
9323 
    L = ['%s=%r' % (key, value)
9324 
      for key, value in self.__dict__.iteritems()]
9325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9326 
 
9327 
  def __eq__(self, other):
9328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9329 
 
9330 
  def __ne__(self, other):
9331 
    return not (self == other)
9332 
 
9333 
class getAffiliateById_args:
9334 
  """
9335 
  Attributes:
9336 
   - id
9337 
  """
9338 
 
9339 
  thrift_spec = (
9340 
    None, # 0
9341 
    (1, TType.I64, 'id', None, None, ), # 1
9342 
  )
9343 
 
9344 
  def __init__(self, id=None,):
9345 
    self.id = id
9346 
 
9347 
  def read(self, iprot):
9348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9350 
      return
9351 
    iprot.readStructBegin()
9352 
    while True:
9353 
      (fname, ftype, fid) = iprot.readFieldBegin()
9354 
      if ftype == TType.STOP:
9355 
        break
9356 
      if fid == 1:
9357 
        if ftype == TType.I64:
9358 
          self.id = iprot.readI64();
9359 
        else:
9360 
          iprot.skip(ftype)
9361 
      else:
9362 
        iprot.skip(ftype)
9363 
      iprot.readFieldEnd()
9364 
    iprot.readStructEnd()
9365 
 
9366 
  def write(self, oprot):
9367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9369 
      return
9370 
    oprot.writeStructBegin('getAffiliateById_args')
3431 rajveer 9371 
    if self.id is not None:
1845 vikas 9372 
      oprot.writeFieldBegin('id', TType.I64, 1)
9373 
      oprot.writeI64(self.id)
9374 
      oprot.writeFieldEnd()
9375 
    oprot.writeFieldStop()
9376 
    oprot.writeStructEnd()
9377 
 
3431 rajveer 9378 
  def validate(self):
9379 
    return
9380 
 
9381 
 
1845 vikas 9382 
  def __repr__(self):
9383 
    L = ['%s=%r' % (key, value)
9384 
      for key, value in self.__dict__.iteritems()]
9385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9386 
 
9387 
  def __eq__(self, other):
9388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9389 
 
9390 
  def __ne__(self, other):
9391 
    return not (self == other)
9392 
 
9393 
class getAffiliateById_result:
9394 
  """
9395 
  Attributes:
9396 
   - success
9397 
   - utx
9398 
  """
9399 
 
9400 
  thrift_spec = (
9401 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9402 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9403 
  )
9404 
 
9405 
  def __init__(self, success=None, utx=None,):
9406 
    self.success = success
9407 
    self.utx = utx
9408 
 
9409 
  def read(self, iprot):
9410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9412 
      return
9413 
    iprot.readStructBegin()
9414 
    while True:
9415 
      (fname, ftype, fid) = iprot.readFieldBegin()
9416 
      if ftype == TType.STOP:
9417 
        break
9418 
      if fid == 0:
9419 
        if ftype == TType.STRUCT:
9420 
          self.success = Affiliate()
9421 
          self.success.read(iprot)
9422 
        else:
9423 
          iprot.skip(ftype)
9424 
      elif fid == 1:
9425 
        if ftype == TType.STRUCT:
1996 vikas 9426 
          self.utx = UserAffiliateException()
1845 vikas 9427 
          self.utx.read(iprot)
9428 
        else:
9429 
          iprot.skip(ftype)
9430 
      else:
9431 
        iprot.skip(ftype)
9432 
      iprot.readFieldEnd()
9433 
    iprot.readStructEnd()
9434 
 
9435 
  def write(self, oprot):
9436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9438 
      return
9439 
    oprot.writeStructBegin('getAffiliateById_result')
3431 rajveer 9440 
    if self.success is not None:
1845 vikas 9441 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9442 
      self.success.write(oprot)
9443 
      oprot.writeFieldEnd()
3431 rajveer 9444 
    if self.utx is not None:
1845 vikas 9445 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9446 
      self.utx.write(oprot)
9447 
      oprot.writeFieldEnd()
9448 
    oprot.writeFieldStop()
9449 
    oprot.writeStructEnd()
9450 
 
3431 rajveer 9451 
  def validate(self):
9452 
    return
9453 
 
9454 
 
1845 vikas 9455 
  def __repr__(self):
9456 
    L = ['%s=%r' % (key, value)
9457 
      for key, value in self.__dict__.iteritems()]
9458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9459 
 
9460 
  def __eq__(self, other):
9461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9462 
 
9463 
  def __ne__(self, other):
9464 
    return not (self == other)
9465 
 
9466 
class getAffiliateByName_args:
9467 
  """
9468 
  Attributes:
9469 
   - name
9470 
  """
9471 
 
9472 
  thrift_spec = (
9473 
    None, # 0
9474 
    (1, TType.STRING, 'name', None, None, ), # 1
9475 
  )
9476 
 
9477 
  def __init__(self, name=None,):
9478 
    self.name = name
9479 
 
9480 
  def read(self, iprot):
9481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9483 
      return
9484 
    iprot.readStructBegin()
9485 
    while True:
9486 
      (fname, ftype, fid) = iprot.readFieldBegin()
9487 
      if ftype == TType.STOP:
9488 
        break
9489 
      if fid == 1:
9490 
        if ftype == TType.STRING:
9491 
          self.name = iprot.readString();
9492 
        else:
9493 
          iprot.skip(ftype)
9494 
      else:
9495 
        iprot.skip(ftype)
9496 
      iprot.readFieldEnd()
9497 
    iprot.readStructEnd()
9498 
 
9499 
  def write(self, oprot):
9500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9502 
      return
9503 
    oprot.writeStructBegin('getAffiliateByName_args')
3431 rajveer 9504 
    if self.name is not None:
1845 vikas 9505 
      oprot.writeFieldBegin('name', TType.STRING, 1)
9506 
      oprot.writeString(self.name)
9507 
      oprot.writeFieldEnd()
9508 
    oprot.writeFieldStop()
9509 
    oprot.writeStructEnd()
9510 
 
3431 rajveer 9511 
  def validate(self):
9512 
    return
9513 
 
9514 
 
1845 vikas 9515 
  def __repr__(self):
9516 
    L = ['%s=%r' % (key, value)
9517 
      for key, value in self.__dict__.iteritems()]
9518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9519 
 
9520 
  def __eq__(self, other):
9521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9522 
 
9523 
  def __ne__(self, other):
9524 
    return not (self == other)
9525 
 
9526 
class getAffiliateByName_result:
9527 
  """
9528 
  Attributes:
9529 
   - success
9530 
   - utx
9531 
  """
9532 
 
9533 
  thrift_spec = (
9534 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 9535 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9536 
  )
9537 
 
9538 
  def __init__(self, success=None, utx=None,):
9539 
    self.success = success
9540 
    self.utx = utx
9541 
 
9542 
  def read(self, iprot):
9543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9545 
      return
9546 
    iprot.readStructBegin()
9547 
    while True:
9548 
      (fname, ftype, fid) = iprot.readFieldBegin()
9549 
      if ftype == TType.STOP:
9550 
        break
9551 
      if fid == 0:
9552 
        if ftype == TType.STRUCT:
9553 
          self.success = Affiliate()
9554 
          self.success.read(iprot)
9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      elif fid == 1:
9558 
        if ftype == TType.STRUCT:
1996 vikas 9559 
          self.utx = UserAffiliateException()
1845 vikas 9560 
          self.utx.read(iprot)
9561 
        else:
9562 
          iprot.skip(ftype)
9563 
      else:
9564 
        iprot.skip(ftype)
9565 
      iprot.readFieldEnd()
9566 
    iprot.readStructEnd()
9567 
 
9568 
  def write(self, oprot):
9569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9571 
      return
9572 
    oprot.writeStructBegin('getAffiliateByName_result')
3431 rajveer 9573 
    if self.success is not None:
1845 vikas 9574 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9575 
      self.success.write(oprot)
9576 
      oprot.writeFieldEnd()
3431 rajveer 9577 
    if self.utx is not None:
1845 vikas 9578 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9579 
      self.utx.write(oprot)
9580 
      oprot.writeFieldEnd()
9581 
    oprot.writeFieldStop()
9582 
    oprot.writeStructEnd()
9583 
 
3431 rajveer 9584 
  def validate(self):
9585 
    return
9586 
 
9587 
 
1845 vikas 9588 
  def __repr__(self):
9589 
    L = ['%s=%r' % (key, value)
9590 
      for key, value in self.__dict__.iteritems()]
9591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9592 
 
9593 
  def __eq__(self, other):
9594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9595 
 
9596 
  def __ne__(self, other):
9597 
    return not (self == other)
9598 
 
1996 vikas 9599 
class getTrackerById_args:
1845 vikas 9600 
  """
9601 
  Attributes:
9602 
   - id
9603 
  """
9604 
 
9605 
  thrift_spec = (
9606 
    None, # 0
9607 
    (1, TType.I64, 'id', None, None, ), # 1
9608 
  )
9609 
 
9610 
  def __init__(self, id=None,):
9611 
    self.id = id
9612 
 
9613 
  def read(self, iprot):
9614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9616 
      return
9617 
    iprot.readStructBegin()
9618 
    while True:
9619 
      (fname, ftype, fid) = iprot.readFieldBegin()
9620 
      if ftype == TType.STOP:
9621 
        break
9622 
      if fid == 1:
9623 
        if ftype == TType.I64:
9624 
          self.id = iprot.readI64();
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      else:
9628 
        iprot.skip(ftype)
9629 
      iprot.readFieldEnd()
9630 
    iprot.readStructEnd()
9631 
 
9632 
  def write(self, oprot):
9633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9635 
      return
1996 vikas 9636 
    oprot.writeStructBegin('getTrackerById_args')
3431 rajveer 9637 
    if self.id is not None:
1845 vikas 9638 
      oprot.writeFieldBegin('id', TType.I64, 1)
9639 
      oprot.writeI64(self.id)
9640 
      oprot.writeFieldEnd()
9641 
    oprot.writeFieldStop()
9642 
    oprot.writeStructEnd()
9643 
 
3431 rajveer 9644 
  def validate(self):
9645 
    return
9646 
 
9647 
 
1845 vikas 9648 
  def __repr__(self):
9649 
    L = ['%s=%r' % (key, value)
9650 
      for key, value in self.__dict__.iteritems()]
9651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9652 
 
9653 
  def __eq__(self, other):
9654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9655 
 
9656 
  def __ne__(self, other):
9657 
    return not (self == other)
9658 
 
9659 
class getTrackerById_result:
9660 
  """
9661 
  Attributes:
9662 
   - success
9663 
   - utx
9664 
  """
9665 
 
9666 
  thrift_spec = (
9667 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 9668 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9669 
  )
9670 
 
9671 
  def __init__(self, success=None, utx=None,):
9672 
    self.success = success
9673 
    self.utx = utx
9674 
 
9675 
  def read(self, iprot):
9676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9678 
      return
9679 
    iprot.readStructBegin()
9680 
    while True:
9681 
      (fname, ftype, fid) = iprot.readFieldBegin()
9682 
      if ftype == TType.STOP:
9683 
        break
9684 
      if fid == 0:
9685 
        if ftype == TType.STRUCT:
9686 
          self.success = Tracker()
9687 
          self.success.read(iprot)
9688 
        else:
9689 
          iprot.skip(ftype)
9690 
      elif fid == 1:
9691 
        if ftype == TType.STRUCT:
1996 vikas 9692 
          self.utx = UserAffiliateException()
1845 vikas 9693 
          self.utx.read(iprot)
9694 
        else:
9695 
          iprot.skip(ftype)
9696 
      else:
9697 
        iprot.skip(ftype)
9698 
      iprot.readFieldEnd()
9699 
    iprot.readStructEnd()
9700 
 
9701 
  def write(self, oprot):
9702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9704 
      return
9705 
    oprot.writeStructBegin('getTrackerById_result')
3431 rajveer 9706 
    if self.success is not None:
1845 vikas 9707 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9708 
      self.success.write(oprot)
9709 
      oprot.writeFieldEnd()
3431 rajveer 9710 
    if self.utx is not None:
1845 vikas 9711 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9712 
      self.utx.write(oprot)
9713 
      oprot.writeFieldEnd()
9714 
    oprot.writeFieldStop()
9715 
    oprot.writeStructEnd()
9716 
 
3431 rajveer 9717 
  def validate(self):
9718 
    return
9719 
 
9720 
 
1845 vikas 9721 
  def __repr__(self):
9722 
    L = ['%s=%r' % (key, value)
9723 
      for key, value in self.__dict__.iteritems()]
9724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9725 
 
9726 
  def __eq__(self, other):
9727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9728 
 
9729 
  def __ne__(self, other):
9730 
    return not (self == other)
9731 
 
1996 vikas 9732 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 9733 
  """
9734 
  Attributes:
1996 vikas 9735 
   - id
1845 vikas 9736 
  """
9737 
 
9738 
  thrift_spec = (
9739 
    None, # 0
1996 vikas 9740 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 9741 
  )
9742 
 
1996 vikas 9743 
  def __init__(self, id=None,):
9744 
    self.id = id
1845 vikas 9745 
 
9746 
  def read(self, iprot):
9747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9749 
      return
9750 
    iprot.readStructBegin()
9751 
    while True:
9752 
      (fname, ftype, fid) = iprot.readFieldBegin()
9753 
      if ftype == TType.STOP:
9754 
        break
9755 
      if fid == 1:
9756 
        if ftype == TType.I64:
1996 vikas 9757 
          self.id = iprot.readI64();
1845 vikas 9758 
        else:
9759 
          iprot.skip(ftype)
9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
1996 vikas 9769 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
3431 rajveer 9770 
    if self.id is not None:
1996 vikas 9771 
      oprot.writeFieldBegin('id', TType.I64, 1)
9772 
      oprot.writeI64(self.id)
1845 vikas 9773 
      oprot.writeFieldEnd()
9774 
    oprot.writeFieldStop()
9775 
    oprot.writeStructEnd()
9776 
 
3431 rajveer 9777 
  def validate(self):
9778 
    return
9779 
 
9780 
 
1845 vikas 9781 
  def __repr__(self):
9782 
    L = ['%s=%r' % (key, value)
9783 
      for key, value in self.__dict__.iteritems()]
9784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9785 
 
9786 
  def __eq__(self, other):
9787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9788 
 
9789 
  def __ne__(self, other):
9790 
    return not (self == other)
9791 
 
1996 vikas 9792 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 9793 
  """
9794 
  Attributes:
9795 
   - success
9796 
   - utx
9797 
  """
9798 
 
9799 
  thrift_spec = (
1996 vikas 9800 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
9801 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9802 
  )
9803 
 
9804 
  def __init__(self, success=None, utx=None,):
9805 
    self.success = success
9806 
    self.utx = utx
9807 
 
9808 
  def read(self, iprot):
9809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9811 
      return
9812 
    iprot.readStructBegin()
9813 
    while True:
9814 
      (fname, ftype, fid) = iprot.readFieldBegin()
9815 
      if ftype == TType.STOP:
9816 
        break
9817 
      if fid == 0:
9818 
        if ftype == TType.LIST:
9819 
          self.success = []
11592 amit.gupta 9820 
          (_etype128, _size125) = iprot.readListBegin()
9821 
          for _i129 in xrange(_size125):
9822 
            _elem130 = Affiliate()
9823 
            _elem130.read(iprot)
9824 
            self.success.append(_elem130)
1845 vikas 9825 
          iprot.readListEnd()
9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      elif fid == 1:
9829 
        if ftype == TType.STRUCT:
1996 vikas 9830 
          self.utx = UserAffiliateException()
1845 vikas 9831 
          self.utx.read(iprot)
9832 
        else:
9833 
          iprot.skip(ftype)
9834 
      else:
9835 
        iprot.skip(ftype)
9836 
      iprot.readFieldEnd()
9837 
    iprot.readStructEnd()
9838 
 
9839 
  def write(self, oprot):
9840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9842 
      return
1996 vikas 9843 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
3431 rajveer 9844 
    if self.success is not None:
1845 vikas 9845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9846 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 9847 
      for iter131 in self.success:
9848 
        iter131.write(oprot)
1845 vikas 9849 
      oprot.writeListEnd()
9850 
      oprot.writeFieldEnd()
3431 rajveer 9851 
    if self.utx is not None:
1845 vikas 9852 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9853 
      self.utx.write(oprot)
9854 
      oprot.writeFieldEnd()
9855 
    oprot.writeFieldStop()
9856 
    oprot.writeStructEnd()
9857 
 
3431 rajveer 9858 
  def validate(self):
9859 
    return
9860 
 
9861 
 
1845 vikas 9862 
  def __repr__(self):
9863 
    L = ['%s=%r' % (key, value)
9864 
      for key, value in self.__dict__.iteritems()]
9865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9866 
 
9867 
  def __eq__(self, other):
9868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9869 
 
9870 
  def __ne__(self, other):
9871 
    return not (self == other)
9872 
 
9873 
class addTrackLog_args:
9874 
  """
9875 
  Attributes:
1996 vikas 9876 
   - affiliateId
1845 vikas 9877 
   - userId
9878 
   - event
9879 
   - url
9880 
   - data
1859 vikas 9881 
   - addedOn
1845 vikas 9882 
  """
9883 
 
9884 
  thrift_spec = (
9885 
    None, # 0
1996 vikas 9886 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 9887 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 9888 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 9889 
    (4, TType.STRING, 'url', None, None, ), # 4
9890 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 9891 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 9892 
  )
9893 
 
1996 vikas 9894 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
9895 
    self.affiliateId = affiliateId
1845 vikas 9896 
    self.userId = userId
9897 
    self.event = event
9898 
    self.url = url
9899 
    self.data = data
1859 vikas 9900 
    self.addedOn = addedOn
1845 vikas 9901 
 
9902 
  def read(self, iprot):
9903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9905 
      return
9906 
    iprot.readStructBegin()
9907 
    while True:
9908 
      (fname, ftype, fid) = iprot.readFieldBegin()
9909 
      if ftype == TType.STOP:
9910 
        break
9911 
      if fid == 1:
9912 
        if ftype == TType.I64:
1996 vikas 9913 
          self.affiliateId = iprot.readI64();
1845 vikas 9914 
        else:
9915 
          iprot.skip(ftype)
9916 
      elif fid == 2:
9917 
        if ftype == TType.I64:
9918 
          self.userId = iprot.readI64();
9919 
        else:
9920 
          iprot.skip(ftype)
9921 
      elif fid == 3:
3378 vikas 9922 
        if ftype == TType.I32:
9923 
          self.event = iprot.readI32();
1845 vikas 9924 
        else:
9925 
          iprot.skip(ftype)
9926 
      elif fid == 4:
9927 
        if ftype == TType.STRING:
9928 
          self.url = iprot.readString();
9929 
        else:
9930 
          iprot.skip(ftype)
9931 
      elif fid == 5:
9932 
        if ftype == TType.STRING:
9933 
          self.data = iprot.readString();
9934 
        else:
9935 
          iprot.skip(ftype)
1859 vikas 9936 
      elif fid == 6:
9937 
        if ftype == TType.I64:
9938 
          self.addedOn = iprot.readI64();
9939 
        else:
9940 
          iprot.skip(ftype)
1845 vikas 9941 
      else:
9942 
        iprot.skip(ftype)
9943 
      iprot.readFieldEnd()
9944 
    iprot.readStructEnd()
9945 
 
9946 
  def write(self, oprot):
9947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9949 
      return
9950 
    oprot.writeStructBegin('addTrackLog_args')
3431 rajveer 9951 
    if self.affiliateId is not None:
1996 vikas 9952 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
9953 
      oprot.writeI64(self.affiliateId)
1845 vikas 9954 
      oprot.writeFieldEnd()
3431 rajveer 9955 
    if self.userId is not None:
1845 vikas 9956 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9957 
      oprot.writeI64(self.userId)
9958 
      oprot.writeFieldEnd()
3431 rajveer 9959 
    if self.event is not None:
3378 vikas 9960 
      oprot.writeFieldBegin('event', TType.I32, 3)
9961 
      oprot.writeI32(self.event)
1845 vikas 9962 
      oprot.writeFieldEnd()
3431 rajveer 9963 
    if self.url is not None:
1845 vikas 9964 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9965 
      oprot.writeString(self.url)
9966 
      oprot.writeFieldEnd()
3431 rajveer 9967 
    if self.data is not None:
1845 vikas 9968 
      oprot.writeFieldBegin('data', TType.STRING, 5)
9969 
      oprot.writeString(self.data)
9970 
      oprot.writeFieldEnd()
3431 rajveer 9971 
    if self.addedOn is not None:
1859 vikas 9972 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
9973 
      oprot.writeI64(self.addedOn)
9974 
      oprot.writeFieldEnd()
1845 vikas 9975 
    oprot.writeFieldStop()
9976 
    oprot.writeStructEnd()
9977 
 
3431 rajveer 9978 
  def validate(self):
9979 
    return
9980 
 
9981 
 
1845 vikas 9982 
  def __repr__(self):
9983 
    L = ['%s=%r' % (key, value)
9984 
      for key, value in self.__dict__.iteritems()]
9985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9986 
 
9987 
  def __eq__(self, other):
9988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9989 
 
9990 
  def __ne__(self, other):
9991 
    return not (self == other)
9992 
 
9993 
class addTrackLog_result:
9994 
  """
9995 
  Attributes:
9996 
   - success
9997 
   - utx
9998 
  """
9999 
 
10000 
  thrift_spec = (
10001 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 10002 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10003 
  )
10004 
 
10005 
  def __init__(self, success=None, utx=None,):
10006 
    self.success = success
10007 
    self.utx = utx
10008 
 
10009 
  def read(self, iprot):
10010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10012 
      return
10013 
    iprot.readStructBegin()
10014 
    while True:
10015 
      (fname, ftype, fid) = iprot.readFieldBegin()
10016 
      if ftype == TType.STOP:
10017 
        break
10018 
      if fid == 0:
10019 
        if ftype == TType.I64:
10020 
          self.success = iprot.readI64();
10021 
        else:
10022 
          iprot.skip(ftype)
10023 
      elif fid == 1:
10024 
        if ftype == TType.STRUCT:
1996 vikas 10025 
          self.utx = UserAffiliateException()
1845 vikas 10026 
          self.utx.read(iprot)
10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      else:
10030 
        iprot.skip(ftype)
10031 
      iprot.readFieldEnd()
10032 
    iprot.readStructEnd()
10033 
 
10034 
  def write(self, oprot):
10035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10037 
      return
10038 
    oprot.writeStructBegin('addTrackLog_result')
3431 rajveer 10039 
    if self.success is not None:
1845 vikas 10040 
      oprot.writeFieldBegin('success', TType.I64, 0)
10041 
      oprot.writeI64(self.success)
10042 
      oprot.writeFieldEnd()
3431 rajveer 10043 
    if self.utx is not None:
1845 vikas 10044 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10045 
      self.utx.write(oprot)
10046 
      oprot.writeFieldEnd()
10047 
    oprot.writeFieldStop()
10048 
    oprot.writeStructEnd()
10049 
 
3431 rajveer 10050 
  def validate(self):
10051 
    return
10052 
 
10053 
 
1845 vikas 10054 
  def __repr__(self):
10055 
    L = ['%s=%r' % (key, value)
10056 
      for key, value in self.__dict__.iteritems()]
10057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10058 
 
10059 
  def __eq__(self, other):
10060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10061 
 
10062 
  def __ne__(self, other):
10063 
    return not (self == other)
10064 
 
10065 
class getTrackLogById_args:
10066 
  """
10067 
  Attributes:
10068 
   - id
10069 
  """
10070 
 
10071 
  thrift_spec = (
10072 
    None, # 0
10073 
    (1, TType.I64, 'id', None, None, ), # 1
10074 
  )
10075 
 
10076 
  def __init__(self, id=None,):
10077 
    self.id = id
10078 
 
10079 
  def read(self, iprot):
10080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10082 
      return
10083 
    iprot.readStructBegin()
10084 
    while True:
10085 
      (fname, ftype, fid) = iprot.readFieldBegin()
10086 
      if ftype == TType.STOP:
10087 
        break
10088 
      if fid == 1:
10089 
        if ftype == TType.I64:
10090 
          self.id = iprot.readI64();
10091 
        else:
10092 
          iprot.skip(ftype)
10093 
      else:
10094 
        iprot.skip(ftype)
10095 
      iprot.readFieldEnd()
10096 
    iprot.readStructEnd()
10097 
 
10098 
  def write(self, oprot):
10099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10101 
      return
10102 
    oprot.writeStructBegin('getTrackLogById_args')
3431 rajveer 10103 
    if self.id is not None:
1845 vikas 10104 
      oprot.writeFieldBegin('id', TType.I64, 1)
10105 
      oprot.writeI64(self.id)
10106 
      oprot.writeFieldEnd()
10107 
    oprot.writeFieldStop()
10108 
    oprot.writeStructEnd()
10109 
 
3431 rajveer 10110 
  def validate(self):
10111 
    return
10112 
 
10113 
 
1845 vikas 10114 
  def __repr__(self):
10115 
    L = ['%s=%r' % (key, value)
10116 
      for key, value in self.__dict__.iteritems()]
10117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10118 
 
10119 
  def __eq__(self, other):
10120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10121 
 
10122 
  def __ne__(self, other):
10123 
    return not (self == other)
10124 
 
10125 
class getTrackLogById_result:
10126 
  """
10127 
  Attributes:
10128 
   - success
10129 
   - utx
10130 
  """
10131 
 
10132 
  thrift_spec = (
10133 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 10134 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10135 
  )
10136 
 
10137 
  def __init__(self, success=None, utx=None,):
10138 
    self.success = success
10139 
    self.utx = utx
10140 
 
10141 
  def read(self, iprot):
10142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10144 
      return
10145 
    iprot.readStructBegin()
10146 
    while True:
10147 
      (fname, ftype, fid) = iprot.readFieldBegin()
10148 
      if ftype == TType.STOP:
10149 
        break
10150 
      if fid == 0:
10151 
        if ftype == TType.STRUCT:
10152 
          self.success = TrackLog()
10153 
          self.success.read(iprot)
10154 
        else:
10155 
          iprot.skip(ftype)
10156 
      elif fid == 1:
10157 
        if ftype == TType.STRUCT:
1996 vikas 10158 
          self.utx = UserAffiliateException()
1845 vikas 10159 
          self.utx.read(iprot)
10160 
        else:
10161 
          iprot.skip(ftype)
10162 
      else:
10163 
        iprot.skip(ftype)
10164 
      iprot.readFieldEnd()
10165 
    iprot.readStructEnd()
10166 
 
10167 
  def write(self, oprot):
10168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10170 
      return
10171 
    oprot.writeStructBegin('getTrackLogById_result')
3431 rajveer 10172 
    if self.success is not None:
1845 vikas 10173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10174 
      self.success.write(oprot)
10175 
      oprot.writeFieldEnd()
3431 rajveer 10176 
    if self.utx is not None:
1845 vikas 10177 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10178 
      self.utx.write(oprot)
10179 
      oprot.writeFieldEnd()
10180 
    oprot.writeFieldStop()
10181 
    oprot.writeStructEnd()
10182 
 
3431 rajveer 10183 
  def validate(self):
10184 
    return
10185 
 
10186 
 
1845 vikas 10187 
  def __repr__(self):
10188 
    L = ['%s=%r' % (key, value)
10189 
      for key, value in self.__dict__.iteritems()]
10190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10191 
 
10192 
  def __eq__(self, other):
10193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10194 
 
10195 
  def __ne__(self, other):
10196 
    return not (self == other)
10197 
 
1996 vikas 10198 
class getTrackLogsByAffiliate_args:
1845 vikas 10199 
  """
10200 
  Attributes:
1996 vikas 10201 
   - affiliateId
3293 vikas 10202 
   - startDate
10203 
   - endDate
1845 vikas 10204 
  """
10205 
 
10206 
  thrift_spec = (
10207 
    None, # 0
1996 vikas 10208 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 10209 
    (2, TType.I64, 'startDate', None, None, ), # 2
10210 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 10211 
  )
10212 
 
3293 vikas 10213 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 10214 
    self.affiliateId = affiliateId
3293 vikas 10215 
    self.startDate = startDate
10216 
    self.endDate = endDate
1845 vikas 10217 
 
10218 
  def read(self, iprot):
10219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10221 
      return
10222 
    iprot.readStructBegin()
10223 
    while True:
10224 
      (fname, ftype, fid) = iprot.readFieldBegin()
10225 
      if ftype == TType.STOP:
10226 
        break
10227 
      if fid == 1:
10228 
        if ftype == TType.I64:
1996 vikas 10229 
          self.affiliateId = iprot.readI64();
1845 vikas 10230 
        else:
10231 
          iprot.skip(ftype)
3293 vikas 10232 
      elif fid == 2:
10233 
        if ftype == TType.I64:
10234 
          self.startDate = iprot.readI64();
10235 
        else:
10236 
          iprot.skip(ftype)
10237 
      elif fid == 3:
10238 
        if ftype == TType.I64:
10239 
          self.endDate = iprot.readI64();
10240 
        else:
10241 
          iprot.skip(ftype)
1845 vikas 10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
1996 vikas 10251 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
3431 rajveer 10252 
    if self.affiliateId is not None:
1996 vikas 10253 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
10254 
      oprot.writeI64(self.affiliateId)
1845 vikas 10255 
      oprot.writeFieldEnd()
3431 rajveer 10256 
    if self.startDate is not None:
3293 vikas 10257 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
10258 
      oprot.writeI64(self.startDate)
10259 
      oprot.writeFieldEnd()
3431 rajveer 10260 
    if self.endDate is not None:
3293 vikas 10261 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
10262 
      oprot.writeI64(self.endDate)
10263 
      oprot.writeFieldEnd()
1845 vikas 10264 
    oprot.writeFieldStop()
10265 
    oprot.writeStructEnd()
10266 
 
3431 rajveer 10267 
  def validate(self):
10268 
    return
10269 
 
10270 
 
1845 vikas 10271 
  def __repr__(self):
10272 
    L = ['%s=%r' % (key, value)
10273 
      for key, value in self.__dict__.iteritems()]
10274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10275 
 
10276 
  def __eq__(self, other):
10277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10278 
 
10279 
  def __ne__(self, other):
10280 
    return not (self == other)
10281 
 
1996 vikas 10282 
class getTrackLogsByAffiliate_result:
1845 vikas 10283 
  """
10284 
  Attributes:
10285 
   - success
10286 
   - utx
10287 
  """
10288 
 
10289 
  thrift_spec = (
10290 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10291 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10292 
  )
10293 
 
10294 
  def __init__(self, success=None, utx=None,):
10295 
    self.success = success
10296 
    self.utx = utx
10297 
 
10298 
  def read(self, iprot):
10299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10301 
      return
10302 
    iprot.readStructBegin()
10303 
    while True:
10304 
      (fname, ftype, fid) = iprot.readFieldBegin()
10305 
      if ftype == TType.STOP:
10306 
        break
10307 
      if fid == 0:
10308 
        if ftype == TType.LIST:
10309 
          self.success = []
11592 amit.gupta 10310 
          (_etype135, _size132) = iprot.readListBegin()
10311 
          for _i136 in xrange(_size132):
10312 
            _elem137 = TrackLog()
10313 
            _elem137.read(iprot)
10314 
            self.success.append(_elem137)
1845 vikas 10315 
          iprot.readListEnd()
10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      elif fid == 1:
10319 
        if ftype == TType.STRUCT:
1996 vikas 10320 
          self.utx = UserAffiliateException()
1845 vikas 10321 
          self.utx.read(iprot)
10322 
        else:
10323 
          iprot.skip(ftype)
10324 
      else:
10325 
        iprot.skip(ftype)
10326 
      iprot.readFieldEnd()
10327 
    iprot.readStructEnd()
10328 
 
10329 
  def write(self, oprot):
10330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10332 
      return
1996 vikas 10333 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
3431 rajveer 10334 
    if self.success is not None:
1845 vikas 10335 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10336 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10337 
      for iter138 in self.success:
10338 
        iter138.write(oprot)
1845 vikas 10339 
      oprot.writeListEnd()
10340 
      oprot.writeFieldEnd()
3431 rajveer 10341 
    if self.utx is not None:
1845 vikas 10342 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10343 
      self.utx.write(oprot)
10344 
      oprot.writeFieldEnd()
10345 
    oprot.writeFieldStop()
10346 
    oprot.writeStructEnd()
10347 
 
3431 rajveer 10348 
  def validate(self):
10349 
    return
10350 
 
10351 
 
1845 vikas 10352 
  def __repr__(self):
10353 
    L = ['%s=%r' % (key, value)
10354 
      for key, value in self.__dict__.iteritems()]
10355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10356 
 
10357 
  def __eq__(self, other):
10358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10359 
 
10360 
  def __ne__(self, other):
10361 
    return not (self == other)
10362 
 
10363 
class getTrackLogsByUser_args:
10364 
  """
10365 
  Attributes:
10366 
   - userId
10367 
  """
10368 
 
10369 
  thrift_spec = (
10370 
    None, # 0
10371 
    (1, TType.I64, 'userId', None, None, ), # 1
10372 
  )
10373 
 
10374 
  def __init__(self, userId=None,):
10375 
    self.userId = userId
10376 
 
10377 
  def read(self, iprot):
10378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10380 
      return
10381 
    iprot.readStructBegin()
10382 
    while True:
10383 
      (fname, ftype, fid) = iprot.readFieldBegin()
10384 
      if ftype == TType.STOP:
10385 
        break
10386 
      if fid == 1:
10387 
        if ftype == TType.I64:
10388 
          self.userId = iprot.readI64();
10389 
        else:
10390 
          iprot.skip(ftype)
10391 
      else:
10392 
        iprot.skip(ftype)
10393 
      iprot.readFieldEnd()
10394 
    iprot.readStructEnd()
10395 
 
10396 
  def write(self, oprot):
10397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10399 
      return
10400 
    oprot.writeStructBegin('getTrackLogsByUser_args')
3431 rajveer 10401 
    if self.userId is not None:
1845 vikas 10402 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10403 
      oprot.writeI64(self.userId)
10404 
      oprot.writeFieldEnd()
10405 
    oprot.writeFieldStop()
10406 
    oprot.writeStructEnd()
10407 
 
3431 rajveer 10408 
  def validate(self):
10409 
    return
10410 
 
10411 
 
1845 vikas 10412 
  def __repr__(self):
10413 
    L = ['%s=%r' % (key, value)
10414 
      for key, value in self.__dict__.iteritems()]
10415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10416 
 
10417 
  def __eq__(self, other):
10418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10419 
 
10420 
  def __ne__(self, other):
10421 
    return not (self == other)
10422 
 
10423 
class getTrackLogsByUser_result:
10424 
  """
10425 
  Attributes:
10426 
   - success
10427 
   - utx
10428 
  """
10429 
 
10430 
  thrift_spec = (
10431 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10432 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10433 
  )
10434 
 
10435 
  def __init__(self, success=None, utx=None,):
10436 
    self.success = success
10437 
    self.utx = utx
10438 
 
10439 
  def read(self, iprot):
10440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10442 
      return
10443 
    iprot.readStructBegin()
10444 
    while True:
10445 
      (fname, ftype, fid) = iprot.readFieldBegin()
10446 
      if ftype == TType.STOP:
10447 
        break
10448 
      if fid == 0:
10449 
        if ftype == TType.LIST:
10450 
          self.success = []
11592 amit.gupta 10451 
          (_etype142, _size139) = iprot.readListBegin()
10452 
          for _i143 in xrange(_size139):
10453 
            _elem144 = TrackLog()
10454 
            _elem144.read(iprot)
10455 
            self.success.append(_elem144)
1845 vikas 10456 
          iprot.readListEnd()
10457 
        else:
10458 
          iprot.skip(ftype)
10459 
      elif fid == 1:
10460 
        if ftype == TType.STRUCT:
1996 vikas 10461 
          self.utx = UserAffiliateException()
1845 vikas 10462 
          self.utx.read(iprot)
10463 
        else:
10464 
          iprot.skip(ftype)
10465 
      else:
10466 
        iprot.skip(ftype)
10467 
      iprot.readFieldEnd()
10468 
    iprot.readStructEnd()
10469 
 
10470 
  def write(self, oprot):
10471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10473 
      return
10474 
    oprot.writeStructBegin('getTrackLogsByUser_result')
3431 rajveer 10475 
    if self.success is not None:
1845 vikas 10476 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10477 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10478 
      for iter145 in self.success:
10479 
        iter145.write(oprot)
1845 vikas 10480 
      oprot.writeListEnd()
10481 
      oprot.writeFieldEnd()
3431 rajveer 10482 
    if self.utx is not None:
1845 vikas 10483 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10484 
      self.utx.write(oprot)
10485 
      oprot.writeFieldEnd()
10486 
    oprot.writeFieldStop()
10487 
    oprot.writeStructEnd()
10488 
 
3431 rajveer 10489 
  def validate(self):
10490 
    return
10491 
 
10492 
 
1845 vikas 10493 
  def __repr__(self):
10494 
    L = ['%s=%r' % (key, value)
10495 
      for key, value in self.__dict__.iteritems()]
10496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10497 
 
10498 
  def __eq__(self, other):
10499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10500 
 
10501 
  def __ne__(self, other):
10502 
    return not (self == other)
10503 
 
10504 
class getTrackLogs_args:
10505 
  """
10506 
  Attributes:
10507 
   - userId
10508 
   - event
10509 
   - url
10510 
  """
10511 
 
10512 
  thrift_spec = (
10513 
    None, # 0
1996 vikas 10514 
    (1, TType.I64, 'userId', None, None, ), # 1
10515 
    (2, TType.STRING, 'event', None, None, ), # 2
10516 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 10517 
  )
10518 
 
1996 vikas 10519 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 10520 
    self.userId = userId
10521 
    self.event = event
10522 
    self.url = url
10523 
 
10524 
  def read(self, iprot):
10525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10527 
      return
10528 
    iprot.readStructBegin()
10529 
    while True:
10530 
      (fname, ftype, fid) = iprot.readFieldBegin()
10531 
      if ftype == TType.STOP:
10532 
        break
10533 
      if fid == 1:
10534 
        if ftype == TType.I64:
1996 vikas 10535 
          self.userId = iprot.readI64();
1845 vikas 10536 
        else:
10537 
          iprot.skip(ftype)
10538 
      elif fid == 2:
10539 
        if ftype == TType.STRING:
10540 
          self.event = iprot.readString();
10541 
        else:
10542 
          iprot.skip(ftype)
1996 vikas 10543 
      elif fid == 3:
1845 vikas 10544 
        if ftype == TType.STRING:
10545 
          self.url = iprot.readString();
10546 
        else:
10547 
          iprot.skip(ftype)
10548 
      else:
10549 
        iprot.skip(ftype)
10550 
      iprot.readFieldEnd()
10551 
    iprot.readStructEnd()
10552 
 
10553 
  def write(self, oprot):
10554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10556 
      return
10557 
    oprot.writeStructBegin('getTrackLogs_args')
3431 rajveer 10558 
    if self.userId is not None:
1996 vikas 10559 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 10560 
      oprot.writeI64(self.userId)
10561 
      oprot.writeFieldEnd()
3431 rajveer 10562 
    if self.event is not None:
1996 vikas 10563 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 10564 
      oprot.writeString(self.event)
10565 
      oprot.writeFieldEnd()
3431 rajveer 10566 
    if self.url is not None:
1996 vikas 10567 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 10568 
      oprot.writeString(self.url)
10569 
      oprot.writeFieldEnd()
10570 
    oprot.writeFieldStop()
10571 
    oprot.writeStructEnd()
10572 
 
3431 rajveer 10573 
  def validate(self):
10574 
    return
10575 
 
10576 
 
1845 vikas 10577 
  def __repr__(self):
10578 
    L = ['%s=%r' % (key, value)
10579 
      for key, value in self.__dict__.iteritems()]
10580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10581 
 
10582 
  def __eq__(self, other):
10583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10584 
 
10585 
  def __ne__(self, other):
10586 
    return not (self == other)
10587 
 
10588 
class getTrackLogs_result:
10589 
  """
10590 
  Attributes:
10591 
   - success
10592 
   - utx
10593 
  """
10594 
 
10595 
  thrift_spec = (
10596 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 10597 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 10598 
  )
10599 
 
10600 
  def __init__(self, success=None, utx=None,):
10601 
    self.success = success
10602 
    self.utx = utx
10603 
 
10604 
  def read(self, iprot):
10605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10607 
      return
10608 
    iprot.readStructBegin()
10609 
    while True:
10610 
      (fname, ftype, fid) = iprot.readFieldBegin()
10611 
      if ftype == TType.STOP:
10612 
        break
10613 
      if fid == 0:
10614 
        if ftype == TType.LIST:
10615 
          self.success = []
11592 amit.gupta 10616 
          (_etype149, _size146) = iprot.readListBegin()
10617 
          for _i150 in xrange(_size146):
10618 
            _elem151 = TrackLog()
10619 
            _elem151.read(iprot)
10620 
            self.success.append(_elem151)
1845 vikas 10621 
          iprot.readListEnd()
10622 
        else:
10623 
          iprot.skip(ftype)
10624 
      elif fid == 1:
10625 
        if ftype == TType.STRUCT:
1996 vikas 10626 
          self.utx = UserAffiliateException()
1845 vikas 10627 
          self.utx.read(iprot)
10628 
        else:
10629 
          iprot.skip(ftype)
10630 
      else:
10631 
        iprot.skip(ftype)
10632 
      iprot.readFieldEnd()
10633 
    iprot.readStructEnd()
10634 
 
10635 
  def write(self, oprot):
10636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10638 
      return
10639 
    oprot.writeStructBegin('getTrackLogs_result')
3431 rajveer 10640 
    if self.success is not None:
1845 vikas 10641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 10643 
      for iter152 in self.success:
10644 
        iter152.write(oprot)
1845 vikas 10645 
      oprot.writeListEnd()
10646 
      oprot.writeFieldEnd()
3431 rajveer 10647 
    if self.utx is not None:
1845 vikas 10648 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
10649 
      self.utx.write(oprot)
10650 
      oprot.writeFieldEnd()
10651 
    oprot.writeFieldStop()
10652 
    oprot.writeStructEnd()
10653 
 
3431 rajveer 10654 
  def validate(self):
10655 
    return
10656 
 
10657 
 
1845 vikas 10658 
  def __repr__(self):
10659 
    L = ['%s=%r' % (key, value)
10660 
      for key, value in self.__dict__.iteritems()]
10661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10662 
 
10663 
  def __eq__(self, other):
10664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10665 
 
10666 
  def __ne__(self, other):
10667 
    return not (self == other)
10668 
 
559 chandransh 10669 
class getCurrentCart_args:
94 ashish 10670 
  """
10671 
  Attributes:
559 chandransh 10672 
   - userId
10673 
  """
10674 
 
10675 
  thrift_spec = (
10676 
    None, # 0
10677 
    (1, TType.I64, 'userId', None, None, ), # 1
10678 
  )
10679 
 
10680 
  def __init__(self, userId=None,):
10681 
    self.userId = userId
10682 
 
10683 
  def read(self, iprot):
10684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10686 
      return
10687 
    iprot.readStructBegin()
10688 
    while True:
10689 
      (fname, ftype, fid) = iprot.readFieldBegin()
10690 
      if ftype == TType.STOP:
10691 
        break
10692 
      if fid == 1:
10693 
        if ftype == TType.I64:
10694 
          self.userId = iprot.readI64();
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      else:
10698 
        iprot.skip(ftype)
10699 
      iprot.readFieldEnd()
10700 
    iprot.readStructEnd()
10701 
 
10702 
  def write(self, oprot):
10703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10705 
      return
10706 
    oprot.writeStructBegin('getCurrentCart_args')
3431 rajveer 10707 
    if self.userId is not None:
559 chandransh 10708 
      oprot.writeFieldBegin('userId', TType.I64, 1)
10709 
      oprot.writeI64(self.userId)
10710 
      oprot.writeFieldEnd()
10711 
    oprot.writeFieldStop()
10712 
    oprot.writeStructEnd()
10713 
 
3431 rajveer 10714 
  def validate(self):
10715 
    return
10716 
 
10717 
 
559 chandransh 10718 
  def __repr__(self):
10719 
    L = ['%s=%r' % (key, value)
10720 
      for key, value in self.__dict__.iteritems()]
10721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10722 
 
10723 
  def __eq__(self, other):
10724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10725 
 
10726 
  def __ne__(self, other):
10727 
    return not (self == other)
10728 
 
10729 
class getCurrentCart_result:
10730 
  """
10731 
  Attributes:
94 ashish 10732 
   - success
559 chandransh 10733 
   - scx
94 ashish 10734 
  """
10735 
 
10736 
  thrift_spec = (
559 chandransh 10737 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10738 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10739 
  )
10740 
 
559 chandransh 10741 
  def __init__(self, success=None, scx=None,):
94 ashish 10742 
    self.success = success
559 chandransh 10743 
    self.scx = scx
94 ashish 10744 
 
10745 
  def read(self, iprot):
10746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10748 
      return
10749 
    iprot.readStructBegin()
10750 
    while True:
10751 
      (fname, ftype, fid) = iprot.readFieldBegin()
10752 
      if ftype == TType.STOP:
10753 
        break
10754 
      if fid == 0:
559 chandransh 10755 
        if ftype == TType.STRUCT:
10756 
          self.success = Cart()
10757 
          self.success.read(iprot)
94 ashish 10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      elif fid == 1:
10761 
        if ftype == TType.STRUCT:
559 chandransh 10762 
          self.scx = ShoppingCartException()
10763 
          self.scx.read(iprot)
94 ashish 10764 
        else:
10765 
          iprot.skip(ftype)
10766 
      else:
10767 
        iprot.skip(ftype)
10768 
      iprot.readFieldEnd()
10769 
    iprot.readStructEnd()
10770 
 
10771 
  def write(self, oprot):
10772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10774 
      return
559 chandransh 10775 
    oprot.writeStructBegin('getCurrentCart_result')
3431 rajveer 10776 
    if self.success is not None:
559 chandransh 10777 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10778 
      self.success.write(oprot)
94 ashish 10779 
      oprot.writeFieldEnd()
3431 rajveer 10780 
    if self.scx is not None:
559 chandransh 10781 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10782 
      self.scx.write(oprot)
94 ashish 10783 
      oprot.writeFieldEnd()
10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
3431 rajveer 10787 
  def validate(self):
10788 
    return
10789 
 
10790 
 
94 ashish 10791 
  def __repr__(self):
10792 
    L = ['%s=%r' % (key, value)
10793 
      for key, value in self.__dict__.iteritems()]
10794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10795 
 
10796 
  def __eq__(self, other):
10797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10798 
 
10799 
  def __ne__(self, other):
10800 
    return not (self == other)
10801 
 
559 chandransh 10802 
class getCart_args:
504 rajveer 10803 
  """
10804 
  Attributes:
559 chandransh 10805 
   - cartId
504 rajveer 10806 
  """
10807 
 
10808 
  thrift_spec = (
10809 
    None, # 0
559 chandransh 10810 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 10811 
  )
10812 
 
559 chandransh 10813 
  def __init__(self, cartId=None,):
10814 
    self.cartId = cartId
504 rajveer 10815 
 
10816 
  def read(self, iprot):
10817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10819 
      return
10820 
    iprot.readStructBegin()
10821 
    while True:
10822 
      (fname, ftype, fid) = iprot.readFieldBegin()
10823 
      if ftype == TType.STOP:
10824 
        break
10825 
      if fid == 1:
10826 
        if ftype == TType.I64:
559 chandransh 10827 
          self.cartId = iprot.readI64();
504 rajveer 10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      else:
10831 
        iprot.skip(ftype)
10832 
      iprot.readFieldEnd()
10833 
    iprot.readStructEnd()
10834 
 
10835 
  def write(self, oprot):
10836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10838 
      return
559 chandransh 10839 
    oprot.writeStructBegin('getCart_args')
3431 rajveer 10840 
    if self.cartId is not None:
559 chandransh 10841 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10842 
      oprot.writeI64(self.cartId)
504 rajveer 10843 
      oprot.writeFieldEnd()
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
3431 rajveer 10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
504 rajveer 10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
559 chandransh 10862 
class getCart_result:
504 rajveer 10863 
  """
10864 
  Attributes:
10865 
   - success
559 chandransh 10866 
   - scx
504 rajveer 10867 
  """
10868 
 
10869 
  thrift_spec = (
559 chandransh 10870 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
10871 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 10872 
  )
10873 
 
559 chandransh 10874 
  def __init__(self, success=None, scx=None,):
504 rajveer 10875 
    self.success = success
559 chandransh 10876 
    self.scx = scx
504 rajveer 10877 
 
10878 
  def read(self, iprot):
10879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10881 
      return
10882 
    iprot.readStructBegin()
10883 
    while True:
10884 
      (fname, ftype, fid) = iprot.readFieldBegin()
10885 
      if ftype == TType.STOP:
10886 
        break
10887 
      if fid == 0:
559 chandransh 10888 
        if ftype == TType.STRUCT:
10889 
          self.success = Cart()
10890 
          self.success.read(iprot)
504 rajveer 10891 
        else:
10892 
          iprot.skip(ftype)
10893 
      elif fid == 1:
10894 
        if ftype == TType.STRUCT:
559 chandransh 10895 
          self.scx = ShoppingCartException()
10896 
          self.scx.read(iprot)
504 rajveer 10897 
        else:
10898 
          iprot.skip(ftype)
10899 
      else:
10900 
        iprot.skip(ftype)
10901 
      iprot.readFieldEnd()
10902 
    iprot.readStructEnd()
10903 
 
10904 
  def write(self, oprot):
10905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10907 
      return
559 chandransh 10908 
    oprot.writeStructBegin('getCart_result')
3431 rajveer 10909 
    if self.success is not None:
559 chandransh 10910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10911 
      self.success.write(oprot)
504 rajveer 10912 
      oprot.writeFieldEnd()
3431 rajveer 10913 
    if self.scx is not None:
559 chandransh 10914 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10915 
      self.scx.write(oprot)
504 rajveer 10916 
      oprot.writeFieldEnd()
10917 
    oprot.writeFieldStop()
10918 
    oprot.writeStructEnd()
10919 
 
3431 rajveer 10920 
  def validate(self):
10921 
    return
10922 
 
10923 
 
504 rajveer 10924 
  def __repr__(self):
10925 
    L = ['%s=%r' % (key, value)
10926 
      for key, value in self.__dict__.iteritems()]
10927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10928 
 
10929 
  def __eq__(self, other):
10930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10931 
 
10932 
  def __ne__(self, other):
10933 
    return not (self == other)
10934 
 
559 chandransh 10935 
class getCartsByTime_args:
10936 
  """
10937 
  Attributes:
10938 
   - from_time
10939 
   - to_time
10940 
   - status
10941 
  """
10942 
 
10943 
  thrift_spec = (
10944 
    None, # 0
10945 
    (1, TType.I64, 'from_time', None, None, ), # 1
10946 
    (2, TType.I64, 'to_time', None, None, ), # 2
10947 
    (3, TType.I32, 'status', None, None, ), # 3
10948 
  )
10949 
 
10950 
  def __init__(self, from_time=None, to_time=None, status=None,):
10951 
    self.from_time = from_time
10952 
    self.to_time = to_time
10953 
    self.status = status
10954 
 
10955 
  def read(self, iprot):
10956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10958 
      return
10959 
    iprot.readStructBegin()
10960 
    while True:
10961 
      (fname, ftype, fid) = iprot.readFieldBegin()
10962 
      if ftype == TType.STOP:
10963 
        break
10964 
      if fid == 1:
94 ashish 10965 
        if ftype == TType.I64:
559 chandransh 10966 
          self.from_time = iprot.readI64();
94 ashish 10967 
        else:
10968 
          iprot.skip(ftype)
122 ashish 10969 
      elif fid == 2:
559 chandransh 10970 
        if ftype == TType.I64:
10971 
          self.to_time = iprot.readI64();
122 ashish 10972 
        else:
10973 
          iprot.skip(ftype)
559 chandransh 10974 
      elif fid == 3:
10975 
        if ftype == TType.I32:
10976 
          self.status = iprot.readI32();
10977 
        else:
10978 
          iprot.skip(ftype)
94 ashish 10979 
      else:
10980 
        iprot.skip(ftype)
10981 
      iprot.readFieldEnd()
10982 
    iprot.readStructEnd()
10983 
 
10984 
  def write(self, oprot):
10985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10987 
      return
559 chandransh 10988 
    oprot.writeStructBegin('getCartsByTime_args')
3431 rajveer 10989 
    if self.from_time is not None:
559 chandransh 10990 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10991 
      oprot.writeI64(self.from_time)
94 ashish 10992 
      oprot.writeFieldEnd()
3431 rajveer 10993 
    if self.to_time is not None:
559 chandransh 10994 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10995 
      oprot.writeI64(self.to_time)
122 ashish 10996 
      oprot.writeFieldEnd()
3431 rajveer 10997 
    if self.status is not None:
559 chandransh 10998 
      oprot.writeFieldBegin('status', TType.I32, 3)
10999 
      oprot.writeI32(self.status)
11000 
      oprot.writeFieldEnd()
94 ashish 11001 
    oprot.writeFieldStop()
11002 
    oprot.writeStructEnd()
11003 
 
3431 rajveer 11004 
  def validate(self):
11005 
    return
11006 
 
11007 
 
94 ashish 11008 
  def __repr__(self):
11009 
    L = ['%s=%r' % (key, value)
11010 
      for key, value in self.__dict__.iteritems()]
11011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11012 
 
11013 
  def __eq__(self, other):
11014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11015 
 
11016 
  def __ne__(self, other):
11017 
    return not (self == other)
11018 
 
559 chandransh 11019 
class getCartsByTime_result:
94 ashish 11020 
  """
11021 
  Attributes:
11022 
   - success
559 chandransh 11023 
   - scx
94 ashish 11024 
  """
11025 
 
11026 
  thrift_spec = (
559 chandransh 11027 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
11028 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11029 
  )
11030 
 
559 chandransh 11031 
  def __init__(self, success=None, scx=None,):
94 ashish 11032 
    self.success = success
559 chandransh 11033 
    self.scx = scx
94 ashish 11034 
 
11035 
  def read(self, iprot):
11036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11038 
      return
11039 
    iprot.readStructBegin()
11040 
    while True:
11041 
      (fname, ftype, fid) = iprot.readFieldBegin()
11042 
      if ftype == TType.STOP:
11043 
        break
11044 
      if fid == 0:
559 chandransh 11045 
        if ftype == TType.LIST:
11046 
          self.success = []
11592 amit.gupta 11047 
          (_etype156, _size153) = iprot.readListBegin()
11048 
          for _i157 in xrange(_size153):
11049 
            _elem158 = Cart()
11050 
            _elem158.read(iprot)
11051 
            self.success.append(_elem158)
559 chandransh 11052 
          iprot.readListEnd()
94 ashish 11053 
        else:
11054 
          iprot.skip(ftype)
11055 
      elif fid == 1:
11056 
        if ftype == TType.STRUCT:
559 chandransh 11057 
          self.scx = ShoppingCartException()
11058 
          self.scx.read(iprot)
94 ashish 11059 
        else:
11060 
          iprot.skip(ftype)
11061 
      else:
11062 
        iprot.skip(ftype)
11063 
      iprot.readFieldEnd()
11064 
    iprot.readStructEnd()
11065 
 
11066 
  def write(self, oprot):
11067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11069 
      return
559 chandransh 11070 
    oprot.writeStructBegin('getCartsByTime_result')
3431 rajveer 11071 
    if self.success is not None:
559 chandransh 11072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11592 amit.gupta 11074 
      for iter159 in self.success:
11075 
        iter159.write(oprot)
559 chandransh 11076 
      oprot.writeListEnd()
94 ashish 11077 
      oprot.writeFieldEnd()
3431 rajveer 11078 
    if self.scx is not None:
559 chandransh 11079 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11080 
      self.scx.write(oprot)
94 ashish 11081 
      oprot.writeFieldEnd()
11082 
    oprot.writeFieldStop()
11083 
    oprot.writeStructEnd()
11084 
 
3431 rajveer 11085 
  def validate(self):
11086 
    return
11087 
 
11088 
 
94 ashish 11089 
  def __repr__(self):
11090 
    L = ['%s=%r' % (key, value)
11091 
      for key, value in self.__dict__.iteritems()]
11092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11093 
 
11094 
  def __eq__(self, other):
11095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11096 
 
11097 
  def __ne__(self, other):
11098 
    return not (self == other)
11099 
 
559 chandransh 11100 
class addItemToCart_args:
11101 
  """
11102 
  Attributes:
11103 
   - cartId
11104 
   - itemId
11105 
   - quantity
3557 rajveer 11106 
   - sourceId
559 chandransh 11107 
  """
11108 
 
11109 
  thrift_spec = (
11110 
    None, # 0
11111 
    (1, TType.I64, 'cartId', None, None, ), # 1
11112 
    (2, TType.I64, 'itemId', None, None, ), # 2
11113 
    (3, TType.I64, 'quantity', None, None, ), # 3
3557 rajveer 11114 
    (4, TType.I64, 'sourceId', None, None, ), # 4
559 chandransh 11115 
  )
11116 
 
3557 rajveer 11117 
  def __init__(self, cartId=None, itemId=None, quantity=None, sourceId=None,):
559 chandransh 11118 
    self.cartId = cartId
11119 
    self.itemId = itemId
11120 
    self.quantity = quantity
3557 rajveer 11121 
    self.sourceId = sourceId
559 chandransh 11122 
 
11123 
  def read(self, iprot):
11124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11126 
      return
11127 
    iprot.readStructBegin()
11128 
    while True:
11129 
      (fname, ftype, fid) = iprot.readFieldBegin()
11130 
      if ftype == TType.STOP:
11131 
        break
11132 
      if fid == 1:
11133 
        if ftype == TType.I64:
11134 
          self.cartId = iprot.readI64();
11135 
        else:
11136 
          iprot.skip(ftype)
11137 
      elif fid == 2:
11138 
        if ftype == TType.I64:
11139 
          self.itemId = iprot.readI64();
11140 
        else:
11141 
          iprot.skip(ftype)
11142 
      elif fid == 3:
11143 
        if ftype == TType.I64:
11144 
          self.quantity = iprot.readI64();
11145 
        else:
11146 
          iprot.skip(ftype)
3557 rajveer 11147 
      elif fid == 4:
11148 
        if ftype == TType.I64:
11149 
          self.sourceId = iprot.readI64();
11150 
        else:
11151 
          iprot.skip(ftype)
559 chandransh 11152 
      else:
11153 
        iprot.skip(ftype)
11154 
      iprot.readFieldEnd()
11155 
    iprot.readStructEnd()
11156 
 
11157 
  def write(self, oprot):
11158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11160 
      return
11161 
    oprot.writeStructBegin('addItemToCart_args')
3431 rajveer 11162 
    if self.cartId is not None:
559 chandransh 11163 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11164 
      oprot.writeI64(self.cartId)
11165 
      oprot.writeFieldEnd()
3431 rajveer 11166 
    if self.itemId is not None:
559 chandransh 11167 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11168 
      oprot.writeI64(self.itemId)
11169 
      oprot.writeFieldEnd()
3431 rajveer 11170 
    if self.quantity is not None:
559 chandransh 11171 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
11172 
      oprot.writeI64(self.quantity)
11173 
      oprot.writeFieldEnd()
3557 rajveer 11174 
    if self.sourceId is not None:
11175 
      oprot.writeFieldBegin('sourceId', TType.I64, 4)
11176 
      oprot.writeI64(self.sourceId)
11177 
      oprot.writeFieldEnd()
559 chandransh 11178 
    oprot.writeFieldStop()
11179 
    oprot.writeStructEnd()
11180 
 
3431 rajveer 11181 
  def validate(self):
11182 
    return
11183 
 
11184 
 
559 chandransh 11185 
  def __repr__(self):
11186 
    L = ['%s=%r' % (key, value)
11187 
      for key, value in self.__dict__.iteritems()]
11188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11189 
 
11190 
  def __eq__(self, other):
11191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11192 
 
11193 
  def __ne__(self, other):
11194 
    return not (self == other)
11195 
 
11196 
class addItemToCart_result:
11197 
  """
11198 
  Attributes:
2035 rajveer 11199 
   - success
559 chandransh 11200 
   - scx
11201 
  """
11202 
 
11203 
  thrift_spec = (
2035 rajveer 11204 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 11205 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11206 
  )
11207 
 
2035 rajveer 11208 
  def __init__(self, success=None, scx=None,):
11209 
    self.success = success
559 chandransh 11210 
    self.scx = scx
11211 
 
11212 
  def read(self, iprot):
11213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11215 
      return
11216 
    iprot.readStructBegin()
11217 
    while True:
11218 
      (fname, ftype, fid) = iprot.readFieldBegin()
11219 
      if ftype == TType.STOP:
11220 
        break
2035 rajveer 11221 
      if fid == 0:
11222 
        if ftype == TType.STRING:
11223 
          self.success = iprot.readString();
11224 
        else:
11225 
          iprot.skip(ftype)
11226 
      elif fid == 1:
559 chandransh 11227 
        if ftype == TType.STRUCT:
11228 
          self.scx = ShoppingCartException()
11229 
          self.scx.read(iprot)
11230 
        else:
11231 
          iprot.skip(ftype)
11232 
      else:
11233 
        iprot.skip(ftype)
11234 
      iprot.readFieldEnd()
11235 
    iprot.readStructEnd()
11236 
 
11237 
  def write(self, oprot):
11238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11240 
      return
11241 
    oprot.writeStructBegin('addItemToCart_result')
3431 rajveer 11242 
    if self.success is not None:
2035 rajveer 11243 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11244 
      oprot.writeString(self.success)
11245 
      oprot.writeFieldEnd()
3431 rajveer 11246 
    if self.scx is not None:
559 chandransh 11247 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11248 
      self.scx.write(oprot)
11249 
      oprot.writeFieldEnd()
11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
3431 rajveer 11253 
  def validate(self):
11254 
    return
11255 
 
11256 
 
559 chandransh 11257 
  def __repr__(self):
11258 
    L = ['%s=%r' % (key, value)
11259 
      for key, value in self.__dict__.iteritems()]
11260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11261 
 
11262 
  def __eq__(self, other):
11263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11264 
 
11265 
  def __ne__(self, other):
11266 
    return not (self == other)
11267 
 
11268 
class deleteItemFromCart_args:
11269 
  """
11270 
  Attributes:
11271 
   - cartId
11272 
   - itemId
11273 
  """
11274 
 
11275 
  thrift_spec = (
11276 
    None, # 0
11277 
    (1, TType.I64, 'cartId', None, None, ), # 1
11278 
    (2, TType.I64, 'itemId', None, None, ), # 2
11279 
  )
11280 
 
11281 
  def __init__(self, cartId=None, itemId=None,):
11282 
    self.cartId = cartId
11283 
    self.itemId = itemId
11284 
 
11285 
  def read(self, iprot):
11286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11288 
      return
11289 
    iprot.readStructBegin()
11290 
    while True:
11291 
      (fname, ftype, fid) = iprot.readFieldBegin()
11292 
      if ftype == TType.STOP:
11293 
        break
11294 
      if fid == 1:
11295 
        if ftype == TType.I64:
11296 
          self.cartId = iprot.readI64();
11297 
        else:
11298 
          iprot.skip(ftype)
11299 
      elif fid == 2:
11300 
        if ftype == TType.I64:
11301 
          self.itemId = iprot.readI64();
11302 
        else:
11303 
          iprot.skip(ftype)
11304 
      else:
11305 
        iprot.skip(ftype)
11306 
      iprot.readFieldEnd()
11307 
    iprot.readStructEnd()
11308 
 
11309 
  def write(self, oprot):
11310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11312 
      return
11313 
    oprot.writeStructBegin('deleteItemFromCart_args')
3431 rajveer 11314 
    if self.cartId is not None:
559 chandransh 11315 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11316 
      oprot.writeI64(self.cartId)
11317 
      oprot.writeFieldEnd()
3431 rajveer 11318 
    if self.itemId is not None:
559 chandransh 11319 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11320 
      oprot.writeI64(self.itemId)
11321 
      oprot.writeFieldEnd()
11322 
    oprot.writeFieldStop()
11323 
    oprot.writeStructEnd()
11324 
 
3431 rajveer 11325 
  def validate(self):
11326 
    return
11327 
 
11328 
 
559 chandransh 11329 
  def __repr__(self):
11330 
    L = ['%s=%r' % (key, value)
11331 
      for key, value in self.__dict__.iteritems()]
11332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11333 
 
11334 
  def __eq__(self, other):
11335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11336 
 
11337 
  def __ne__(self, other):
11338 
    return not (self == other)
11339 
 
11340 
class deleteItemFromCart_result:
11341 
  """
11342 
  Attributes:
11343 
   - scx
11344 
  """
11345 
 
11346 
  thrift_spec = (
11347 
    None, # 0
11348 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11349 
  )
11350 
 
11351 
  def __init__(self, scx=None,):
11352 
    self.scx = scx
11353 
 
11354 
  def read(self, iprot):
11355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11357 
      return
11358 
    iprot.readStructBegin()
11359 
    while True:
11360 
      (fname, ftype, fid) = iprot.readFieldBegin()
11361 
      if ftype == TType.STOP:
11362 
        break
11363 
      if fid == 1:
11364 
        if ftype == TType.STRUCT:
11365 
          self.scx = ShoppingCartException()
11366 
          self.scx.read(iprot)
11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      else:
11370 
        iprot.skip(ftype)
11371 
      iprot.readFieldEnd()
11372 
    iprot.readStructEnd()
11373 
 
11374 
  def write(self, oprot):
11375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11377 
      return
11378 
    oprot.writeStructBegin('deleteItemFromCart_result')
3431 rajveer 11379 
    if self.scx is not None:
559 chandransh 11380 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11381 
      self.scx.write(oprot)
11382 
      oprot.writeFieldEnd()
11383 
    oprot.writeFieldStop()
11384 
    oprot.writeStructEnd()
11385 
 
3431 rajveer 11386 
  def validate(self):
11387 
    return
11388 
 
11389 
 
559 chandransh 11390 
  def __repr__(self):
11391 
    L = ['%s=%r' % (key, value)
11392 
      for key, value in self.__dict__.iteritems()]
11393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11394 
 
11395 
  def __eq__(self, other):
11396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11397 
 
11398 
  def __ne__(self, other):
11399 
    return not (self == other)
11400 
 
11401 
class addAddressToCart_args:
11402 
  """
11403 
  Attributes:
11404 
   - cartId
11405 
   - addressId
11406 
  """
11407 
 
11408 
  thrift_spec = (
11409 
    None, # 0
11410 
    (1, TType.I64, 'cartId', None, None, ), # 1
11411 
    (2, TType.I64, 'addressId', None, None, ), # 2
11412 
  )
11413 
 
11414 
  def __init__(self, cartId=None, addressId=None,):
11415 
    self.cartId = cartId
11416 
    self.addressId = addressId
11417 
 
11418 
  def read(self, iprot):
11419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11421 
      return
11422 
    iprot.readStructBegin()
11423 
    while True:
11424 
      (fname, ftype, fid) = iprot.readFieldBegin()
11425 
      if ftype == TType.STOP:
11426 
        break
11427 
      if fid == 1:
11428 
        if ftype == TType.I64:
11429 
          self.cartId = iprot.readI64();
11430 
        else:
11431 
          iprot.skip(ftype)
11432 
      elif fid == 2:
11433 
        if ftype == TType.I64:
11434 
          self.addressId = iprot.readI64();
11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
11446 
    oprot.writeStructBegin('addAddressToCart_args')
3431 rajveer 11447 
    if self.cartId is not None:
559 chandransh 11448 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11449 
      oprot.writeI64(self.cartId)
11450 
      oprot.writeFieldEnd()
3431 rajveer 11451 
    if self.addressId is not None:
559 chandransh 11452 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
11453 
      oprot.writeI64(self.addressId)
11454 
      oprot.writeFieldEnd()
11455 
    oprot.writeFieldStop()
11456 
    oprot.writeStructEnd()
11457 
 
3431 rajveer 11458 
  def validate(self):
11459 
    return
11460 
 
11461 
 
559 chandransh 11462 
  def __repr__(self):
11463 
    L = ['%s=%r' % (key, value)
11464 
      for key, value in self.__dict__.iteritems()]
11465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11466 
 
11467 
  def __eq__(self, other):
11468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11469 
 
11470 
  def __ne__(self, other):
11471 
    return not (self == other)
11472 
 
11473 
class addAddressToCart_result:
575 chandransh 11474 
  """
11475 
  Attributes:
11476 
   - scx
11477 
  """
559 chandransh 11478 
 
11479 
  thrift_spec = (
575 chandransh 11480 
    None, # 0
11481 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11482 
  )
11483 
 
575 chandransh 11484 
  def __init__(self, scx=None,):
11485 
    self.scx = scx
11486 
 
559 chandransh 11487 
  def read(self, iprot):
11488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11490 
      return
11491 
    iprot.readStructBegin()
11492 
    while True:
11493 
      (fname, ftype, fid) = iprot.readFieldBegin()
11494 
      if ftype == TType.STOP:
11495 
        break
575 chandransh 11496 
      if fid == 1:
11497 
        if ftype == TType.STRUCT:
11498 
          self.scx = ShoppingCartException()
11499 
          self.scx.read(iprot)
11500 
        else:
11501 
          iprot.skip(ftype)
559 chandransh 11502 
      else:
11503 
        iprot.skip(ftype)
11504 
      iprot.readFieldEnd()
11505 
    iprot.readStructEnd()
11506 
 
11507 
  def write(self, oprot):
11508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11510 
      return
11511 
    oprot.writeStructBegin('addAddressToCart_result')
3431 rajveer 11512 
    if self.scx is not None:
575 chandransh 11513 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11514 
      self.scx.write(oprot)
11515 
      oprot.writeFieldEnd()
559 chandransh 11516 
    oprot.writeFieldStop()
11517 
    oprot.writeStructEnd()
11518 
 
3431 rajveer 11519 
  def validate(self):
11520 
    return
11521 
 
11522 
 
559 chandransh 11523 
  def __repr__(self):
11524 
    L = ['%s=%r' % (key, value)
11525 
      for key, value in self.__dict__.iteritems()]
11526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11527 
 
11528 
  def __eq__(self, other):
11529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11530 
 
11531 
  def __ne__(self, other):
11532 
    return not (self == other)
11533 
 
5553 rajveer 11534 
class addStoreToCart_args:
11535 
  """
11536 
  Attributes:
11537 
   - cartId
11538 
   - storeId
11539 
  """
11540 
 
11541 
  thrift_spec = (
11542 
    None, # 0
11543 
    (1, TType.I64, 'cartId', None, None, ), # 1
11544 
    (2, TType.I64, 'storeId', None, None, ), # 2
11545 
  )
11546 
 
11547 
  def __init__(self, cartId=None, storeId=None,):
11548 
    self.cartId = cartId
11549 
    self.storeId = storeId
11550 
 
11551 
  def read(self, iprot):
11552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11554 
      return
11555 
    iprot.readStructBegin()
11556 
    while True:
11557 
      (fname, ftype, fid) = iprot.readFieldBegin()
11558 
      if ftype == TType.STOP:
11559 
        break
11560 
      if fid == 1:
11561 
        if ftype == TType.I64:
11562 
          self.cartId = iprot.readI64();
11563 
        else:
11564 
          iprot.skip(ftype)
11565 
      elif fid == 2:
11566 
        if ftype == TType.I64:
11567 
          self.storeId = iprot.readI64();
11568 
        else:
11569 
          iprot.skip(ftype)
11570 
      else:
11571 
        iprot.skip(ftype)
11572 
      iprot.readFieldEnd()
11573 
    iprot.readStructEnd()
11574 
 
11575 
  def write(self, oprot):
11576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11578 
      return
11579 
    oprot.writeStructBegin('addStoreToCart_args')
11580 
    if self.cartId is not None:
11581 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11582 
      oprot.writeI64(self.cartId)
11583 
      oprot.writeFieldEnd()
11584 
    if self.storeId is not None:
11585 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
11586 
      oprot.writeI64(self.storeId)
11587 
      oprot.writeFieldEnd()
11588 
    oprot.writeFieldStop()
11589 
    oprot.writeStructEnd()
11590 
 
11591 
  def validate(self):
11592 
    return
11593 
 
11594 
 
11595 
  def __repr__(self):
11596 
    L = ['%s=%r' % (key, value)
11597 
      for key, value in self.__dict__.iteritems()]
11598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11599 
 
11600 
  def __eq__(self, other):
11601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11602 
 
11603 
  def __ne__(self, other):
11604 
    return not (self == other)
11605 
 
11606 
class addStoreToCart_result:
11607 
  """
11608 
  Attributes:
11609 
   - scx
11610 
  """
11611 
 
11612 
  thrift_spec = (
11613 
    None, # 0
11614 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11615 
  )
11616 
 
11617 
  def __init__(self, scx=None,):
11618 
    self.scx = scx
11619 
 
11620 
  def read(self, iprot):
11621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11623 
      return
11624 
    iprot.readStructBegin()
11625 
    while True:
11626 
      (fname, ftype, fid) = iprot.readFieldBegin()
11627 
      if ftype == TType.STOP:
11628 
        break
11629 
      if fid == 1:
11630 
        if ftype == TType.STRUCT:
11631 
          self.scx = ShoppingCartException()
11632 
          self.scx.read(iprot)
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      else:
11636 
        iprot.skip(ftype)
11637 
      iprot.readFieldEnd()
11638 
    iprot.readStructEnd()
11639 
 
11640 
  def write(self, oprot):
11641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11643 
      return
11644 
    oprot.writeStructBegin('addStoreToCart_result')
11645 
    if self.scx is not None:
11646 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11647 
      self.scx.write(oprot)
11648 
      oprot.writeFieldEnd()
11649 
    oprot.writeFieldStop()
11650 
    oprot.writeStructEnd()
11651 
 
11652 
  def validate(self):
11653 
    return
11654 
 
11655 
 
11656 
  def __repr__(self):
11657 
    L = ['%s=%r' % (key, value)
11658 
      for key, value in self.__dict__.iteritems()]
11659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11660 
 
11661 
  def __eq__(self, other):
11662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11663 
 
11664 
  def __ne__(self, other):
11665 
    return not (self == other)
11666 
 
1976 varun.gupt 11667 
class applyCouponToCart_args:
11668 
  """
11669 
  Attributes:
6922 anupam.sin 11670 
   - cart
1976 varun.gupt 11671 
   - couponCode
11672 
  """
11673 
 
11674 
  thrift_spec = (
11675 
    None, # 0
6922 anupam.sin 11676 
    (1, TType.STRUCT, 'cart', (Cart, Cart.thrift_spec), None, ), # 1
1976 varun.gupt 11677 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
11678 
  )
11679 
 
6922 anupam.sin 11680 
  def __init__(self, cart=None, couponCode=None,):
11681 
    self.cart = cart
1976 varun.gupt 11682 
    self.couponCode = couponCode
11683 
 
11684 
  def read(self, iprot):
11685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11687 
      return
11688 
    iprot.readStructBegin()
11689 
    while True:
11690 
      (fname, ftype, fid) = iprot.readFieldBegin()
11691 
      if ftype == TType.STOP:
11692 
        break
11693 
      if fid == 1:
6922 anupam.sin 11694 
        if ftype == TType.STRUCT:
11695 
          self.cart = Cart()
11696 
          self.cart.read(iprot)
1976 varun.gupt 11697 
        else:
11698 
          iprot.skip(ftype)
11699 
      elif fid == 2:
11700 
        if ftype == TType.STRING:
11701 
          self.couponCode = iprot.readString();
11702 
        else:
11703 
          iprot.skip(ftype)
11704 
      else:
11705 
        iprot.skip(ftype)
11706 
      iprot.readFieldEnd()
11707 
    iprot.readStructEnd()
11708 
 
11709 
  def write(self, oprot):
11710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11712 
      return
11713 
    oprot.writeStructBegin('applyCouponToCart_args')
6922 anupam.sin 11714 
    if self.cart is not None:
11715 
      oprot.writeFieldBegin('cart', TType.STRUCT, 1)
11716 
      self.cart.write(oprot)
1976 varun.gupt 11717 
      oprot.writeFieldEnd()
3431 rajveer 11718 
    if self.couponCode is not None:
1976 varun.gupt 11719 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
11720 
      oprot.writeString(self.couponCode)
11721 
      oprot.writeFieldEnd()
11722 
    oprot.writeFieldStop()
11723 
    oprot.writeStructEnd()
11724 
 
3431 rajveer 11725 
  def validate(self):
11726 
    return
11727 
 
11728 
 
1976 varun.gupt 11729 
  def __repr__(self):
11730 
    L = ['%s=%r' % (key, value)
11731 
      for key, value in self.__dict__.iteritems()]
11732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11733 
 
11734 
  def __eq__(self, other):
11735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11736 
 
11737 
  def __ne__(self, other):
11738 
    return not (self == other)
11739 
 
11740 
class applyCouponToCart_result:
11741 
  """
11742 
  Attributes:
11743 
   - scx
11744 
  """
11745 
 
11746 
  thrift_spec = (
11747 
    None, # 0
11748 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11749 
  )
11750 
 
11751 
  def __init__(self, scx=None,):
11752 
    self.scx = scx
11753 
 
11754 
  def read(self, iprot):
11755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11757 
      return
11758 
    iprot.readStructBegin()
11759 
    while True:
11760 
      (fname, ftype, fid) = iprot.readFieldBegin()
11761 
      if ftype == TType.STOP:
11762 
        break
11763 
      if fid == 1:
11764 
        if ftype == TType.STRUCT:
11765 
          self.scx = ShoppingCartException()
11766 
          self.scx.read(iprot)
11767 
        else:
11768 
          iprot.skip(ftype)
11769 
      else:
11770 
        iprot.skip(ftype)
11771 
      iprot.readFieldEnd()
11772 
    iprot.readStructEnd()
11773 
 
11774 
  def write(self, oprot):
11775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11777 
      return
11778 
    oprot.writeStructBegin('applyCouponToCart_result')
3431 rajveer 11779 
    if self.scx is not None:
1976 varun.gupt 11780 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11781 
      self.scx.write(oprot)
11782 
      oprot.writeFieldEnd()
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
3431 rajveer 11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
1976 varun.gupt 11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
11801 
class removeCoupon_args:
11802 
  """
11803 
  Attributes:
11804 
   - cartId
11805 
  """
11806 
 
11807 
  thrift_spec = (
11808 
    None, # 0
11809 
    (1, TType.I64, 'cartId', None, None, ), # 1
11810 
  )
11811 
 
11812 
  def __init__(self, cartId=None,):
11813 
    self.cartId = cartId
11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 1:
11825 
        if ftype == TType.I64:
11826 
          self.cartId = iprot.readI64();
11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
11838 
    oprot.writeStructBegin('removeCoupon_args')
3431 rajveer 11839 
    if self.cartId is not None:
1976 varun.gupt 11840 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11841 
      oprot.writeI64(self.cartId)
11842 
      oprot.writeFieldEnd()
11843 
    oprot.writeFieldStop()
11844 
    oprot.writeStructEnd()
11845 
 
3431 rajveer 11846 
  def validate(self):
11847 
    return
11848 
 
11849 
 
1976 varun.gupt 11850 
  def __repr__(self):
11851 
    L = ['%s=%r' % (key, value)
11852 
      for key, value in self.__dict__.iteritems()]
11853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11854 
 
11855 
  def __eq__(self, other):
11856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11857 
 
11858 
  def __ne__(self, other):
11859 
    return not (self == other)
11860 
 
11861 
class removeCoupon_result:
11862 
  """
11863 
  Attributes:
11864 
   - scx
11865 
  """
11866 
 
11867 
  thrift_spec = (
11868 
    None, # 0
11869 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11870 
  )
11871 
 
11872 
  def __init__(self, scx=None,):
11873 
    self.scx = scx
11874 
 
11875 
  def read(self, iprot):
11876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11878 
      return
11879 
    iprot.readStructBegin()
11880 
    while True:
11881 
      (fname, ftype, fid) = iprot.readFieldBegin()
11882 
      if ftype == TType.STOP:
11883 
        break
11884 
      if fid == 1:
11885 
        if ftype == TType.STRUCT:
11886 
          self.scx = ShoppingCartException()
11887 
          self.scx.read(iprot)
11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      else:
11891 
        iprot.skip(ftype)
11892 
      iprot.readFieldEnd()
11893 
    iprot.readStructEnd()
11894 
 
11895 
  def write(self, oprot):
11896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11898 
      return
11899 
    oprot.writeStructBegin('removeCoupon_result')
3431 rajveer 11900 
    if self.scx is not None:
1976 varun.gupt 11901 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11902 
      self.scx.write(oprot)
11903 
      oprot.writeFieldEnd()
11904 
    oprot.writeFieldStop()
11905 
    oprot.writeStructEnd()
11906 
 
3431 rajveer 11907 
  def validate(self):
11908 
    return
11909 
 
11910 
 
1976 varun.gupt 11911 
  def __repr__(self):
11912 
    L = ['%s=%r' % (key, value)
11913 
      for key, value in self.__dict__.iteritems()]
11914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11915 
 
11916 
  def __eq__(self, other):
11917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11918 
 
11919 
  def __ne__(self, other):
11920 
    return not (self == other)
11921 
 
3554 varun.gupt 11922 
class deleteDiscountsFromCart_args:
11923 
  """
11924 
  Attributes:
11925 
   - cartId
11926 
  """
11927 
 
11928 
  thrift_spec = (
11929 
    None, # 0
11930 
    (1, TType.I64, 'cartId', None, None, ), # 1
11931 
  )
11932 
 
11933 
  def __init__(self, cartId=None,):
11934 
    self.cartId = cartId
11935 
 
11936 
  def read(self, iprot):
11937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11939 
      return
11940 
    iprot.readStructBegin()
11941 
    while True:
11942 
      (fname, ftype, fid) = iprot.readFieldBegin()
11943 
      if ftype == TType.STOP:
11944 
        break
11945 
      if fid == 1:
11946 
        if ftype == TType.I64:
11947 
          self.cartId = iprot.readI64();
11948 
        else:
11949 
          iprot.skip(ftype)
11950 
      else:
11951 
        iprot.skip(ftype)
11952 
      iprot.readFieldEnd()
11953 
    iprot.readStructEnd()
11954 
 
11955 
  def write(self, oprot):
11956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11958 
      return
11959 
    oprot.writeStructBegin('deleteDiscountsFromCart_args')
11960 
    if self.cartId is not None:
11961 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11962 
      oprot.writeI64(self.cartId)
11963 
      oprot.writeFieldEnd()
11964 
    oprot.writeFieldStop()
11965 
    oprot.writeStructEnd()
11966 
 
11967 
  def validate(self):
11968 
    return
11969 
 
11970 
 
11971 
  def __repr__(self):
11972 
    L = ['%s=%r' % (key, value)
11973 
      for key, value in self.__dict__.iteritems()]
11974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11975 
 
11976 
  def __eq__(self, other):
11977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11978 
 
11979 
  def __ne__(self, other):
11980 
    return not (self == other)
11981 
 
11982 
class deleteDiscountsFromCart_result:
11983 
  """
11984 
  Attributes:
11985 
   - scx
11986 
  """
11987 
 
11988 
  thrift_spec = (
11989 
    None, # 0
11990 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11991 
  )
11992 
 
11993 
  def __init__(self, scx=None,):
11994 
    self.scx = scx
11995 
 
11996 
  def read(self, iprot):
11997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11999 
      return
12000 
    iprot.readStructBegin()
12001 
    while True:
12002 
      (fname, ftype, fid) = iprot.readFieldBegin()
12003 
      if ftype == TType.STOP:
12004 
        break
12005 
      if fid == 1:
12006 
        if ftype == TType.STRUCT:
12007 
          self.scx = ShoppingCartException()
12008 
          self.scx.read(iprot)
12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
12020 
    oprot.writeStructBegin('deleteDiscountsFromCart_result')
12021 
    if self.scx is not None:
12022 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12023 
      self.scx.write(oprot)
12024 
      oprot.writeFieldEnd()
12025 
    oprot.writeFieldStop()
12026 
    oprot.writeStructEnd()
12027 
 
12028 
  def validate(self):
12029 
    return
12030 
 
12031 
 
12032 
  def __repr__(self):
12033 
    L = ['%s=%r' % (key, value)
12034 
      for key, value in self.__dict__.iteritems()]
12035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12036 
 
12037 
  def __eq__(self, other):
12038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12039 
 
12040 
  def __ne__(self, other):
12041 
    return not (self == other)
12042 
 
12043 
class saveDiscounts_args:
12044 
  """
12045 
  Attributes:
12046 
   - discounts
12047 
  """
12048 
 
12049 
  thrift_spec = (
12050 
    None, # 0
12051 
    (1, TType.LIST, 'discounts', (TType.STRUCT,(Discount, Discount.thrift_spec)), None, ), # 1
12052 
  )
12053 
 
12054 
  def __init__(self, discounts=None,):
12055 
    self.discounts = discounts
12056 
 
12057 
  def read(self, iprot):
12058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12060 
      return
12061 
    iprot.readStructBegin()
12062 
    while True:
12063 
      (fname, ftype, fid) = iprot.readFieldBegin()
12064 
      if ftype == TType.STOP:
12065 
        break
12066 
      if fid == 1:
12067 
        if ftype == TType.LIST:
12068 
          self.discounts = []
11592 amit.gupta 12069 
          (_etype163, _size160) = iprot.readListBegin()
12070 
          for _i164 in xrange(_size160):
12071 
            _elem165 = Discount()
12072 
            _elem165.read(iprot)
12073 
            self.discounts.append(_elem165)
3554 varun.gupt 12074 
          iprot.readListEnd()
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      else:
12078 
        iprot.skip(ftype)
12079 
      iprot.readFieldEnd()
12080 
    iprot.readStructEnd()
12081 
 
12082 
  def write(self, oprot):
12083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12085 
      return
12086 
    oprot.writeStructBegin('saveDiscounts_args')
12087 
    if self.discounts is not None:
12088 
      oprot.writeFieldBegin('discounts', TType.LIST, 1)
12089 
      oprot.writeListBegin(TType.STRUCT, len(self.discounts))
11592 amit.gupta 12090 
      for iter166 in self.discounts:
12091 
        iter166.write(oprot)
3554 varun.gupt 12092 
      oprot.writeListEnd()
12093 
      oprot.writeFieldEnd()
12094 
    oprot.writeFieldStop()
12095 
    oprot.writeStructEnd()
12096 
 
12097 
  def validate(self):
12098 
    return
12099 
 
12100 
 
12101 
  def __repr__(self):
12102 
    L = ['%s=%r' % (key, value)
12103 
      for key, value in self.__dict__.iteritems()]
12104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12105 
 
12106 
  def __eq__(self, other):
12107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12108 
 
12109 
  def __ne__(self, other):
12110 
    return not (self == other)
12111 
 
12112 
class saveDiscounts_result:
12113 
  """
12114 
  Attributes:
12115 
   - scx
12116 
  """
12117 
 
12118 
  thrift_spec = (
12119 
    None, # 0
12120 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12121 
  )
12122 
 
12123 
  def __init__(self, scx=None,):
12124 
    self.scx = scx
12125 
 
12126 
  def read(self, iprot):
12127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12129 
      return
12130 
    iprot.readStructBegin()
12131 
    while True:
12132 
      (fname, ftype, fid) = iprot.readFieldBegin()
12133 
      if ftype == TType.STOP:
12134 
        break
12135 
      if fid == 1:
12136 
        if ftype == TType.STRUCT:
12137 
          self.scx = ShoppingCartException()
12138 
          self.scx.read(iprot)
12139 
        else:
12140 
          iprot.skip(ftype)
12141 
      else:
12142 
        iprot.skip(ftype)
12143 
      iprot.readFieldEnd()
12144 
    iprot.readStructEnd()
12145 
 
12146 
  def write(self, oprot):
12147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12149 
      return
12150 
    oprot.writeStructBegin('saveDiscounts_result')
12151 
    if self.scx is not None:
12152 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12153 
      self.scx.write(oprot)
12154 
      oprot.writeFieldEnd()
12155 
    oprot.writeFieldStop()
12156 
    oprot.writeStructEnd()
12157 
 
12158 
  def validate(self):
12159 
    return
12160 
 
12161 
 
12162 
  def __repr__(self):
12163 
    L = ['%s=%r' % (key, value)
12164 
      for key, value in self.__dict__.iteritems()]
12165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12166 
 
12167 
  def __eq__(self, other):
12168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12169 
 
12170 
  def __ne__(self, other):
12171 
    return not (self == other)
12172 
 
690 chandransh 12173 
class createOrders_args:
559 chandransh 12174 
  """
12175 
  Attributes:
12176 
   - cartId
2815 vikas 12177 
   - sessionSource
12178 
   - sessionStartTime
3858 vikas 12179 
   - firstSource
12180 
   - firstSourceTime
5326 rajveer 12181 
   - userId
6389 rajveer 12182 
   - schemeId
11526 amit.gupta 12183 
   - orderSource
559 chandransh 12184 
  """
12185 
 
12186 
  thrift_spec = (
12187 
    None, # 0
12188 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 12189 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
12190 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
3858 vikas 12191 
    (4, TType.STRING, 'firstSource', None, None, ), # 4
12192 
    (5, TType.I64, 'firstSourceTime', None, None, ), # 5
5326 rajveer 12193 
    (6, TType.I64, 'userId', None, None, ), # 6
6389 rajveer 12194 
    (7, TType.I64, 'schemeId', None, None, ), # 7
11526 amit.gupta 12195 
    (8, TType.I64, 'orderSource', None, None, ), # 8
559 chandransh 12196 
  )
12197 
 
11526 amit.gupta 12198 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None, firstSource=None, firstSourceTime=None, userId=None, schemeId=None, orderSource=None,):
559 chandransh 12199 
    self.cartId = cartId
2815 vikas 12200 
    self.sessionSource = sessionSource
12201 
    self.sessionStartTime = sessionStartTime
3858 vikas 12202 
    self.firstSource = firstSource
12203 
    self.firstSourceTime = firstSourceTime
5326 rajveer 12204 
    self.userId = userId
6389 rajveer 12205 
    self.schemeId = schemeId
11526 amit.gupta 12206 
    self.orderSource = orderSource
559 chandransh 12207 
 
12208 
  def read(self, iprot):
12209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12211 
      return
12212 
    iprot.readStructBegin()
12213 
    while True:
12214 
      (fname, ftype, fid) = iprot.readFieldBegin()
12215 
      if ftype == TType.STOP:
12216 
        break
12217 
      if fid == 1:
12218 
        if ftype == TType.I64:
12219 
          self.cartId = iprot.readI64();
12220 
        else:
12221 
          iprot.skip(ftype)
2815 vikas 12222 
      elif fid == 2:
12223 
        if ftype == TType.STRING:
12224 
          self.sessionSource = iprot.readString();
12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      elif fid == 3:
12228 
        if ftype == TType.I64:
12229 
          self.sessionStartTime = iprot.readI64();
12230 
        else:
12231 
          iprot.skip(ftype)
3858 vikas 12232 
      elif fid == 4:
12233 
        if ftype == TType.STRING:
12234 
          self.firstSource = iprot.readString();
12235 
        else:
12236 
          iprot.skip(ftype)
12237 
      elif fid == 5:
12238 
        if ftype == TType.I64:
12239 
          self.firstSourceTime = iprot.readI64();
12240 
        else:
12241 
          iprot.skip(ftype)
5326 rajveer 12242 
      elif fid == 6:
12243 
        if ftype == TType.I64:
12244 
          self.userId = iprot.readI64();
12245 
        else:
12246 
          iprot.skip(ftype)
6389 rajveer 12247 
      elif fid == 7:
12248 
        if ftype == TType.I64:
12249 
          self.schemeId = iprot.readI64();
12250 
        else:
12251 
          iprot.skip(ftype)
11526 amit.gupta 12252 
      elif fid == 8:
12253 
        if ftype == TType.I64:
12254 
          self.orderSource = iprot.readI64();
12255 
        else:
12256 
          iprot.skip(ftype)
559 chandransh 12257 
      else:
12258 
        iprot.skip(ftype)
12259 
      iprot.readFieldEnd()
12260 
    iprot.readStructEnd()
12261 
 
12262 
  def write(self, oprot):
12263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12265 
      return
690 chandransh 12266 
    oprot.writeStructBegin('createOrders_args')
3431 rajveer 12267 
    if self.cartId is not None:
559 chandransh 12268 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12269 
      oprot.writeI64(self.cartId)
12270 
      oprot.writeFieldEnd()
3431 rajveer 12271 
    if self.sessionSource is not None:
2815 vikas 12272 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
12273 
      oprot.writeString(self.sessionSource)
12274 
      oprot.writeFieldEnd()
3431 rajveer 12275 
    if self.sessionStartTime is not None:
2815 vikas 12276 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
12277 
      oprot.writeI64(self.sessionStartTime)
12278 
      oprot.writeFieldEnd()
3858 vikas 12279 
    if self.firstSource is not None:
12280 
      oprot.writeFieldBegin('firstSource', TType.STRING, 4)
12281 
      oprot.writeString(self.firstSource)
12282 
      oprot.writeFieldEnd()
12283 
    if self.firstSourceTime is not None:
12284 
      oprot.writeFieldBegin('firstSourceTime', TType.I64, 5)
12285 
      oprot.writeI64(self.firstSourceTime)
12286 
      oprot.writeFieldEnd()
5326 rajveer 12287 
    if self.userId is not None:
12288 
      oprot.writeFieldBegin('userId', TType.I64, 6)
12289 
      oprot.writeI64(self.userId)
12290 
      oprot.writeFieldEnd()
6389 rajveer 12291 
    if self.schemeId is not None:
12292 
      oprot.writeFieldBegin('schemeId', TType.I64, 7)
12293 
      oprot.writeI64(self.schemeId)
12294 
      oprot.writeFieldEnd()
11526 amit.gupta 12295 
    if self.orderSource is not None:
12296 
      oprot.writeFieldBegin('orderSource', TType.I64, 8)
12297 
      oprot.writeI64(self.orderSource)
12298 
      oprot.writeFieldEnd()
559 chandransh 12299 
    oprot.writeFieldStop()
12300 
    oprot.writeStructEnd()
12301 
 
3431 rajveer 12302 
  def validate(self):
12303 
    return
12304 
 
12305 
 
559 chandransh 12306 
  def __repr__(self):
12307 
    L = ['%s=%r' % (key, value)
12308 
      for key, value in self.__dict__.iteritems()]
12309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12310 
 
12311 
  def __eq__(self, other):
12312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12313 
 
12314 
  def __ne__(self, other):
12315 
    return not (self == other)
12316 
 
690 chandransh 12317 
class createOrders_result:
559 chandransh 12318 
  """
12319 
  Attributes:
94 ashish 12320 
   - success
559 chandransh 12321 
   - scx
94 ashish 12322 
  """
12323 
 
12324 
  thrift_spec = (
575 chandransh 12325 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 12326 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12327 
  )
12328 
 
559 chandransh 12329 
  def __init__(self, success=None, scx=None,):
94 ashish 12330 
    self.success = success
559 chandransh 12331 
    self.scx = scx
94 ashish 12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 0:
575 chandransh 12343 
        if ftype == TType.I64:
12344 
          self.success = iprot.readI64();
94 ashish 12345 
        else:
12346 
          iprot.skip(ftype)
12347 
      elif fid == 1:
12348 
        if ftype == TType.STRUCT:
559 chandransh 12349 
          self.scx = ShoppingCartException()
12350 
          self.scx.read(iprot)
94 ashish 12351 
        else:
12352 
          iprot.skip(ftype)
12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
690 chandransh 12362 
    oprot.writeStructBegin('createOrders_result')
3431 rajveer 12363 
    if self.success is not None:
575 chandransh 12364 
      oprot.writeFieldBegin('success', TType.I64, 0)
12365 
      oprot.writeI64(self.success)
94 ashish 12366 
      oprot.writeFieldEnd()
3431 rajveer 12367 
    if self.scx is not None:
559 chandransh 12368 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12369 
      self.scx.write(oprot)
94 ashish 12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
3431 rajveer 12374 
  def validate(self):
12375 
    return
12376 
 
12377 
 
94 ashish 12378 
  def __repr__(self):
12379 
    L = ['%s=%r' % (key, value)
12380 
      for key, value in self.__dict__.iteritems()]
12381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12382 
 
12383 
  def __eq__(self, other):
12384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12385 
 
12386 
  def __ne__(self, other):
12387 
    return not (self == other)
12388 
 
559 chandransh 12389 
class validateCart_args:
94 ashish 12390 
  """
12391 
  Attributes:
559 chandransh 12392 
   - cartId
3557 rajveer 12393 
   - sourceId
94 ashish 12394 
  """
12395 
 
12396 
  thrift_spec = (
12397 
    None, # 0
559 chandransh 12398 
    (1, TType.I64, 'cartId', None, None, ), # 1
3557 rajveer 12399 
    (2, TType.I64, 'sourceId', None, None, ), # 2
94 ashish 12400 
  )
12401 
 
3557 rajveer 12402 
  def __init__(self, cartId=None, sourceId=None,):
559 chandransh 12403 
    self.cartId = cartId
3557 rajveer 12404 
    self.sourceId = sourceId
94 ashish 12405 
 
12406 
  def read(self, iprot):
12407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12409 
      return
12410 
    iprot.readStructBegin()
12411 
    while True:
12412 
      (fname, ftype, fid) = iprot.readFieldBegin()
12413 
      if ftype == TType.STOP:
12414 
        break
12415 
      if fid == 1:
12416 
        if ftype == TType.I64:
559 chandransh 12417 
          self.cartId = iprot.readI64();
94 ashish 12418 
        else:
12419 
          iprot.skip(ftype)
3557 rajveer 12420 
      elif fid == 2:
12421 
        if ftype == TType.I64:
12422 
          self.sourceId = iprot.readI64();
12423 
        else:
12424 
          iprot.skip(ftype)
94 ashish 12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
559 chandransh 12434 
    oprot.writeStructBegin('validateCart_args')
3431 rajveer 12435 
    if self.cartId is not None:
559 chandransh 12436 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12437 
      oprot.writeI64(self.cartId)
94 ashish 12438 
      oprot.writeFieldEnd()
3557 rajveer 12439 
    if self.sourceId is not None:
12440 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12441 
      oprot.writeI64(self.sourceId)
12442 
      oprot.writeFieldEnd()
94 ashish 12443 
    oprot.writeFieldStop()
12444 
    oprot.writeStructEnd()
12445 
 
3431 rajveer 12446 
  def validate(self):
12447 
    return
12448 
 
12449 
 
94 ashish 12450 
  def __repr__(self):
12451 
    L = ['%s=%r' % (key, value)
12452 
      for key, value in self.__dict__.iteritems()]
12453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12454 
 
12455 
  def __eq__(self, other):
12456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12457 
 
12458 
  def __ne__(self, other):
12459 
    return not (self == other)
12460 
 
559 chandransh 12461 
class validateCart_result:
94 ashish 12462 
  """
12463 
  Attributes:
12464 
   - success
575 chandransh 12465 
   - scex
94 ashish 12466 
  """
12467 
 
12468 
  thrift_spec = (
6736 amit.gupta 12469 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
575 chandransh 12470 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 12471 
  )
12472 
 
575 chandransh 12473 
  def __init__(self, success=None, scex=None,):
94 ashish 12474 
    self.success = success
575 chandransh 12475 
    self.scex = scex
94 ashish 12476 
 
12477 
  def read(self, iprot):
12478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12480 
      return
12481 
    iprot.readStructBegin()
12482 
    while True:
12483 
      (fname, ftype, fid) = iprot.readFieldBegin()
12484 
      if ftype == TType.STOP:
12485 
        break
12486 
      if fid == 0:
6736 amit.gupta 12487 
        if ftype == TType.LIST:
12488 
          self.success = []
11592 amit.gupta 12489 
          (_etype170, _size167) = iprot.readListBegin()
12490 
          for _i171 in xrange(_size167):
12491 
            _elem172 = iprot.readString();
12492 
            self.success.append(_elem172)
6736 amit.gupta 12493 
          iprot.readListEnd()
94 ashish 12494 
        else:
12495 
          iprot.skip(ftype)
575 chandransh 12496 
      elif fid == 1:
12497 
        if ftype == TType.STRUCT:
12498 
          self.scex = ShoppingCartException()
12499 
          self.scex.read(iprot)
12500 
        else:
12501 
          iprot.skip(ftype)
94 ashish 12502 
      else:
12503 
        iprot.skip(ftype)
12504 
      iprot.readFieldEnd()
12505 
    iprot.readStructEnd()
12506 
 
12507 
  def write(self, oprot):
12508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12510 
      return
559 chandransh 12511 
    oprot.writeStructBegin('validateCart_result')
3431 rajveer 12512 
    if self.success is not None:
6736 amit.gupta 12513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12514 
      oprot.writeListBegin(TType.STRING, len(self.success))
11592 amit.gupta 12515 
      for iter173 in self.success:
12516 
        oprot.writeString(iter173)
6736 amit.gupta 12517 
      oprot.writeListEnd()
94 ashish 12518 
      oprot.writeFieldEnd()
3431 rajveer 12519 
    if self.scex is not None:
575 chandransh 12520 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12521 
      self.scex.write(oprot)
12522 
      oprot.writeFieldEnd()
559 chandransh 12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
3431 rajveer 12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
559 chandransh 12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
11980 amit.gupta 12541 
class validateCartWithDealerCoupon_args:
12542 
  """
12543 
  Attributes:
12544 
   - cartId
12545 
   - sourceId
12546 
   - dealCoupon
12547 
  """
12548 
 
12549 
  thrift_spec = (
12550 
    None, # 0
12551 
    (1, TType.I64, 'cartId', None, None, ), # 1
12552 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12553 
    (3, TType.STRING, 'dealCoupon', None, None, ), # 3
12554 
  )
12555 
 
12556 
  def __init__(self, cartId=None, sourceId=None, dealCoupon=None,):
12557 
    self.cartId = cartId
12558 
    self.sourceId = sourceId
12559 
    self.dealCoupon = dealCoupon
12560 
 
12561 
  def read(self, iprot):
12562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12564 
      return
12565 
    iprot.readStructBegin()
12566 
    while True:
12567 
      (fname, ftype, fid) = iprot.readFieldBegin()
12568 
      if ftype == TType.STOP:
12569 
        break
12570 
      if fid == 1:
12571 
        if ftype == TType.I64:
12572 
          self.cartId = iprot.readI64();
12573 
        else:
12574 
          iprot.skip(ftype)
12575 
      elif fid == 2:
12576 
        if ftype == TType.I64:
12577 
          self.sourceId = iprot.readI64();
12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      elif fid == 3:
12581 
        if ftype == TType.STRING:
12582 
          self.dealCoupon = iprot.readString();
12583 
        else:
12584 
          iprot.skip(ftype)
12585 
      else:
12586 
        iprot.skip(ftype)
12587 
      iprot.readFieldEnd()
12588 
    iprot.readStructEnd()
12589 
 
12590 
  def write(self, oprot):
12591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12593 
      return
12594 
    oprot.writeStructBegin('validateCartWithDealerCoupon_args')
12595 
    if self.cartId is not None:
12596 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12597 
      oprot.writeI64(self.cartId)
12598 
      oprot.writeFieldEnd()
12599 
    if self.sourceId is not None:
12600 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12601 
      oprot.writeI64(self.sourceId)
12602 
      oprot.writeFieldEnd()
12603 
    if self.dealCoupon is not None:
12604 
      oprot.writeFieldBegin('dealCoupon', TType.STRING, 3)
12605 
      oprot.writeString(self.dealCoupon)
12606 
      oprot.writeFieldEnd()
12607 
    oprot.writeFieldStop()
12608 
    oprot.writeStructEnd()
12609 
 
12610 
  def validate(self):
12611 
    return
12612 
 
12613 
 
12614 
  def __repr__(self):
12615 
    L = ['%s=%r' % (key, value)
12616 
      for key, value in self.__dict__.iteritems()]
12617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12618 
 
12619 
  def __eq__(self, other):
12620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12621 
 
12622 
  def __ne__(self, other):
12623 
    return not (self == other)
12624 
 
12625 
class validateCartWithDealerCoupon_result:
12626 
  """
12627 
  Attributes:
12628 
   - success
12629 
   - scex
12630 
  """
12631 
 
12632 
  thrift_spec = (
12633 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12634 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12635 
  )
12636 
 
12637 
  def __init__(self, success=None, scex=None,):
12638 
    self.success = success
12639 
    self.scex = scex
12640 
 
12641 
  def read(self, iprot):
12642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12644 
      return
12645 
    iprot.readStructBegin()
12646 
    while True:
12647 
      (fname, ftype, fid) = iprot.readFieldBegin()
12648 
      if ftype == TType.STOP:
12649 
        break
12650 
      if fid == 0:
12651 
        if ftype == TType.LIST:
12652 
          self.success = []
12653 
          (_etype177, _size174) = iprot.readListBegin()
12654 
          for _i178 in xrange(_size174):
12655 
            _elem179 = iprot.readString();
12656 
            self.success.append(_elem179)
12657 
          iprot.readListEnd()
12658 
        else:
12659 
          iprot.skip(ftype)
12660 
      elif fid == 1:
12661 
        if ftype == TType.STRUCT:
12662 
          self.scex = ShoppingCartException()
12663 
          self.scex.read(iprot)
12664 
        else:
12665 
          iprot.skip(ftype)
12666 
      else:
12667 
        iprot.skip(ftype)
12668 
      iprot.readFieldEnd()
12669 
    iprot.readStructEnd()
12670 
 
12671 
  def write(self, oprot):
12672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12674 
      return
12675 
    oprot.writeStructBegin('validateCartWithDealerCoupon_result')
12676 
    if self.success is not None:
12677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12678 
      oprot.writeListBegin(TType.STRING, len(self.success))
12679 
      for iter180 in self.success:
12680 
        oprot.writeString(iter180)
12681 
      oprot.writeListEnd()
12682 
      oprot.writeFieldEnd()
12683 
    if self.scex is not None:
12684 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12685 
      self.scex.write(oprot)
12686 
      oprot.writeFieldEnd()
12687 
    oprot.writeFieldStop()
12688 
    oprot.writeStructEnd()
12689 
 
12690 
  def validate(self):
12691 
    return
12692 
 
12693 
 
12694 
  def __repr__(self):
12695 
    L = ['%s=%r' % (key, value)
12696 
      for key, value in self.__dict__.iteritems()]
12697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12698 
 
12699 
  def __eq__(self, other):
12700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12701 
 
12702 
  def __ne__(self, other):
12703 
    return not (self == other)
12704 
 
690 chandransh 12705 
class mergeCart_args:
575 chandransh 12706 
  """
12707 
  Attributes:
690 chandransh 12708 
   - fromCartId
12709 
   - toCartId
12710 
  """
12711 
 
12712 
  thrift_spec = (
12713 
    None, # 0
12714 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
12715 
    (2, TType.I64, 'toCartId', None, None, ), # 2
12716 
  )
12717 
 
12718 
  def __init__(self, fromCartId=None, toCartId=None,):
12719 
    self.fromCartId = fromCartId
12720 
    self.toCartId = toCartId
12721 
 
12722 
  def read(self, iprot):
12723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12725 
      return
12726 
    iprot.readStructBegin()
12727 
    while True:
12728 
      (fname, ftype, fid) = iprot.readFieldBegin()
12729 
      if ftype == TType.STOP:
12730 
        break
12731 
      if fid == 1:
12732 
        if ftype == TType.I64:
12733 
          self.fromCartId = iprot.readI64();
12734 
        else:
12735 
          iprot.skip(ftype)
12736 
      elif fid == 2:
12737 
        if ftype == TType.I64:
12738 
          self.toCartId = iprot.readI64();
12739 
        else:
12740 
          iprot.skip(ftype)
12741 
      else:
12742 
        iprot.skip(ftype)
12743 
      iprot.readFieldEnd()
12744 
    iprot.readStructEnd()
12745 
 
12746 
  def write(self, oprot):
12747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12749 
      return
12750 
    oprot.writeStructBegin('mergeCart_args')
3431 rajveer 12751 
    if self.fromCartId is not None:
690 chandransh 12752 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
12753 
      oprot.writeI64(self.fromCartId)
12754 
      oprot.writeFieldEnd()
3431 rajveer 12755 
    if self.toCartId is not None:
690 chandransh 12756 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
12757 
      oprot.writeI64(self.toCartId)
12758 
      oprot.writeFieldEnd()
12759 
    oprot.writeFieldStop()
12760 
    oprot.writeStructEnd()
12761 
 
3431 rajveer 12762 
  def validate(self):
12763 
    return
12764 
 
12765 
 
690 chandransh 12766 
  def __repr__(self):
12767 
    L = ['%s=%r' % (key, value)
12768 
      for key, value in self.__dict__.iteritems()]
12769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12770 
 
12771 
  def __eq__(self, other):
12772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12773 
 
12774 
  def __ne__(self, other):
12775 
    return not (self == other)
12776 
 
12777 
class mergeCart_result:
12778 
 
12779 
  thrift_spec = (
12780 
  )
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      else:
12792 
        iprot.skip(ftype)
12793 
      iprot.readFieldEnd()
12794 
    iprot.readStructEnd()
12795 
 
12796 
  def write(self, oprot):
12797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12799 
      return
12800 
    oprot.writeStructBegin('mergeCart_result')
12801 
    oprot.writeFieldStop()
12802 
    oprot.writeStructEnd()
12803 
 
3431 rajveer 12804 
  def validate(self):
12805 
    return
12806 
 
12807 
 
690 chandransh 12808 
  def __repr__(self):
12809 
    L = ['%s=%r' % (key, value)
12810 
      for key, value in self.__dict__.iteritems()]
12811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12812 
 
12813 
  def __eq__(self, other):
12814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12815 
 
12816 
  def __ne__(self, other):
12817 
    return not (self == other)
12818 
 
12819 
class checkOut_args:
12820 
  """
12821 
  Attributes:
575 chandransh 12822 
   - cartId
12823 
  """
12824 
 
12825 
  thrift_spec = (
12826 
    None, # 0
12827 
    (1, TType.I64, 'cartId', None, None, ), # 1
12828 
  )
12829 
 
12830 
  def __init__(self, cartId=None,):
12831 
    self.cartId = cartId
12832 
 
12833 
  def read(self, iprot):
12834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12836 
      return
12837 
    iprot.readStructBegin()
12838 
    while True:
12839 
      (fname, ftype, fid) = iprot.readFieldBegin()
12840 
      if ftype == TType.STOP:
12841 
        break
12842 
      if fid == 1:
12843 
        if ftype == TType.I64:
12844 
          self.cartId = iprot.readI64();
12845 
        else:
12846 
          iprot.skip(ftype)
12847 
      else:
12848 
        iprot.skip(ftype)
12849 
      iprot.readFieldEnd()
12850 
    iprot.readStructEnd()
12851 
 
12852 
  def write(self, oprot):
12853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12855 
      return
690 chandransh 12856 
    oprot.writeStructBegin('checkOut_args')
3431 rajveer 12857 
    if self.cartId is not None:
575 chandransh 12858 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
12859 
      oprot.writeI64(self.cartId)
12860 
      oprot.writeFieldEnd()
12861 
    oprot.writeFieldStop()
12862 
    oprot.writeStructEnd()
12863 
 
3431 rajveer 12864 
  def validate(self):
12865 
    return
12866 
 
12867 
 
575 chandransh 12868 
  def __repr__(self):
12869 
    L = ['%s=%r' % (key, value)
12870 
      for key, value in self.__dict__.iteritems()]
12871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12872 
 
12873 
  def __eq__(self, other):
12874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12875 
 
12876 
  def __ne__(self, other):
12877 
    return not (self == other)
12878 
 
690 chandransh 12879 
class checkOut_result:
575 chandransh 12880 
  """
12881 
  Attributes:
12882 
   - success
12883 
   - scex
12884 
  """
12885 
 
12886 
  thrift_spec = (
12887 
    (0, TType.BOOL, 'success', None, None, ), # 0
12888 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
12889 
  )
12890 
 
12891 
  def __init__(self, success=None, scex=None,):
12892 
    self.success = success
12893 
    self.scex = scex
12894 
 
12895 
  def read(self, iprot):
12896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12898 
      return
12899 
    iprot.readStructBegin()
12900 
    while True:
12901 
      (fname, ftype, fid) = iprot.readFieldBegin()
12902 
      if ftype == TType.STOP:
12903 
        break
12904 
      if fid == 0:
12905 
        if ftype == TType.BOOL:
12906 
          self.success = iprot.readBool();
12907 
        else:
12908 
          iprot.skip(ftype)
12909 
      elif fid == 1:
12910 
        if ftype == TType.STRUCT:
12911 
          self.scex = ShoppingCartException()
12912 
          self.scex.read(iprot)
12913 
        else:
12914 
          iprot.skip(ftype)
12915 
      else:
12916 
        iprot.skip(ftype)
12917 
      iprot.readFieldEnd()
12918 
    iprot.readStructEnd()
12919 
 
12920 
  def write(self, oprot):
12921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12923 
      return
690 chandransh 12924 
    oprot.writeStructBegin('checkOut_result')
3431 rajveer 12925 
    if self.success is not None:
575 chandransh 12926 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12927 
      oprot.writeBool(self.success)
12928 
      oprot.writeFieldEnd()
3431 rajveer 12929 
    if self.scex is not None:
575 chandransh 12930 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
12931 
      self.scex.write(oprot)
12932 
      oprot.writeFieldEnd()
12933 
    oprot.writeFieldStop()
12934 
    oprot.writeStructEnd()
12935 
 
3431 rajveer 12936 
  def validate(self):
12937 
    return
12938 
 
12939 
 
575 chandransh 12940 
  def __repr__(self):
12941 
    L = ['%s=%r' % (key, value)
12942 
      for key, value in self.__dict__.iteritems()]
12943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12944 
 
12945 
  def __eq__(self, other):
12946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12947 
 
12948 
  def __ne__(self, other):
12949 
    return not (self == other)
12950 
 
690 chandransh 12951 
class resetCart_args:
559 chandransh 12952 
  """
12953 
  Attributes:
690 chandransh 12954 
   - cartId
12955 
   - items
559 chandransh 12956 
  """
12957 
 
12958 
  thrift_spec = (
12959 
    None, # 0
690 chandransh 12960 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 12961 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 12962 
  )
12963 
 
690 chandransh 12964 
  def __init__(self, cartId=None, items=None,):
12965 
    self.cartId = cartId
12966 
    self.items = items
559 chandransh 12967 
 
12968 
  def read(self, iprot):
12969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12971 
      return
12972 
    iprot.readStructBegin()
12973 
    while True:
12974 
      (fname, ftype, fid) = iprot.readFieldBegin()
12975 
      if ftype == TType.STOP:
12976 
        break
12977 
      if fid == 1:
12978 
        if ftype == TType.I64:
690 chandransh 12979 
          self.cartId = iprot.readI64();
559 chandransh 12980 
        else:
12981 
          iprot.skip(ftype)
12982 
      elif fid == 2:
690 chandransh 12983 
        if ftype == TType.MAP:
12984 
          self.items = {}
11980 amit.gupta 12985 
          (_ktype182, _vtype183, _size181 ) = iprot.readMapBegin()
12986 
          for _i185 in xrange(_size181):
12987 
            _key186 = iprot.readI64();
12988 
            _val187 = iprot.readDouble();
12989 
            self.items[_key186] = _val187
690 chandransh 12990 
          iprot.readMapEnd()
559 chandransh 12991 
        else:
12992 
          iprot.skip(ftype)
12993 
      else:
12994 
        iprot.skip(ftype)
12995 
      iprot.readFieldEnd()
12996 
    iprot.readStructEnd()
12997 
 
12998 
  def write(self, oprot):
12999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13001 
      return
690 chandransh 13002 
    oprot.writeStructBegin('resetCart_args')
3431 rajveer 13003 
    if self.cartId is not None:
690 chandransh 13004 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
13005 
      oprot.writeI64(self.cartId)
94 ashish 13006 
      oprot.writeFieldEnd()
3431 rajveer 13007 
    if self.items is not None:
690 chandransh 13008 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 13009 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
11980 amit.gupta 13010 
      for kiter188,viter189 in self.items.items():
13011 
        oprot.writeI64(kiter188)
13012 
        oprot.writeDouble(viter189)
690 chandransh 13013 
      oprot.writeMapEnd()
559 chandransh 13014 
      oprot.writeFieldEnd()
94 ashish 13015 
    oprot.writeFieldStop()
13016 
    oprot.writeStructEnd()
13017 
 
3431 rajveer 13018 
  def validate(self):
13019 
    return
13020 
 
13021 
 
94 ashish 13022 
  def __repr__(self):
13023 
    L = ['%s=%r' % (key, value)
13024 
      for key, value in self.__dict__.iteritems()]
13025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13026 
 
13027 
  def __eq__(self, other):
13028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13029 
 
13030 
  def __ne__(self, other):
13031 
    return not (self == other)
13032 
 
690 chandransh 13033 
class resetCart_result:
13034 
  """
13035 
  Attributes:
13036 
   - success
13037 
   - scex
13038 
  """
559 chandransh 13039 
 
13040 
  thrift_spec = (
690 chandransh 13041 
    (0, TType.BOOL, 'success', None, None, ), # 0
13042 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 13043 
  )
13044 
 
690 chandransh 13045 
  def __init__(self, success=None, scex=None,):
13046 
    self.success = success
13047 
    self.scex = scex
13048 
 
559 chandransh 13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
690 chandransh 13058 
      if fid == 0:
13059 
        if ftype == TType.BOOL:
13060 
          self.success = iprot.readBool();
13061 
        else:
13062 
          iprot.skip(ftype)
13063 
      elif fid == 1:
13064 
        if ftype == TType.STRUCT:
13065 
          self.scex = ShoppingCartException()
13066 
          self.scex.read(iprot)
13067 
        else:
13068 
          iprot.skip(ftype)
559 chandransh 13069 
      else:
13070 
        iprot.skip(ftype)
13071 
      iprot.readFieldEnd()
13072 
    iprot.readStructEnd()
13073 
 
13074 
  def write(self, oprot):
13075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13077 
      return
690 chandransh 13078 
    oprot.writeStructBegin('resetCart_result')
3431 rajveer 13079 
    if self.success is not None:
690 chandransh 13080 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13081 
      oprot.writeBool(self.success)
13082 
      oprot.writeFieldEnd()
3431 rajveer 13083 
    if self.scex is not None:
690 chandransh 13084 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
13085 
      self.scex.write(oprot)
13086 
      oprot.writeFieldEnd()
559 chandransh 13087 
    oprot.writeFieldStop()
13088 
    oprot.writeStructEnd()
13089 
 
3431 rajveer 13090 
  def validate(self):
13091 
    return
13092 
 
13093 
 
559 chandransh 13094 
  def __repr__(self):
13095 
    L = ['%s=%r' % (key, value)
13096 
      for key, value in self.__dict__.iteritems()]
13097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13098 
 
13099 
  def __eq__(self, other):
13100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13101 
 
13102 
  def __ne__(self, other):
13103 
    return not (self == other)
13104 
 
2981 rajveer 13105 
class getUserCount_args:
94 ashish 13106 
  """
13107 
  Attributes:
2981 rajveer 13108 
   - userType
559 chandransh 13109 
  """
13110 
 
13111 
  thrift_spec = (
13112 
    None, # 0
2981 rajveer 13113 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 13114 
  )
13115 
 
2981 rajveer 13116 
  def __init__(self, userType=None,):
13117 
    self.userType = userType
559 chandransh 13118 
 
13119 
  def read(self, iprot):
13120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13122 
      return
13123 
    iprot.readStructBegin()
13124 
    while True:
13125 
      (fname, ftype, fid) = iprot.readFieldBegin()
13126 
      if ftype == TType.STOP:
13127 
        break
13128 
      if fid == 1:
2981 rajveer 13129 
        if ftype == TType.I32:
13130 
          self.userType = iprot.readI32();
559 chandransh 13131 
        else:
13132 
          iprot.skip(ftype)
13133 
      else:
13134 
        iprot.skip(ftype)
13135 
      iprot.readFieldEnd()
13136 
    iprot.readStructEnd()
13137 
 
13138 
  def write(self, oprot):
13139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13141 
      return
2981 rajveer 13142 
    oprot.writeStructBegin('getUserCount_args')
3431 rajveer 13143 
    if self.userType is not None:
2981 rajveer 13144 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13145 
      oprot.writeI32(self.userType)
559 chandransh 13146 
      oprot.writeFieldEnd()
13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
3431 rajveer 13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
559 chandransh 13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
2981 rajveer 13165 
class getUserCount_result:
94 ashish 13166 
  """
13167 
  Attributes:
13168 
   - success
13169 
  """
13170 
 
13171 
  thrift_spec = (
2981 rajveer 13172 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13173 
  )
13174 
 
2981 rajveer 13175 
  def __init__(self, success=None,):
94 ashish 13176 
    self.success = success
13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 0:
2981 rajveer 13188 
        if ftype == TType.I64:
13189 
          self.success = iprot.readI64();
94 ashish 13190 
        else:
13191 
          iprot.skip(ftype)
13192 
      else:
13193 
        iprot.skip(ftype)
13194 
      iprot.readFieldEnd()
13195 
    iprot.readStructEnd()
13196 
 
13197 
  def write(self, oprot):
13198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13200 
      return
2981 rajveer 13201 
    oprot.writeStructBegin('getUserCount_result')
3431 rajveer 13202 
    if self.success is not None:
2981 rajveer 13203 
      oprot.writeFieldBegin('success', TType.I64, 0)
13204 
      oprot.writeI64(self.success)
94 ashish 13205 
      oprot.writeFieldEnd()
13206 
    oprot.writeFieldStop()
13207 
    oprot.writeStructEnd()
13208 
 
3431 rajveer 13209 
  def validate(self):
13210 
    return
13211 
 
13212 
 
94 ashish 13213 
  def __repr__(self):
13214 
    L = ['%s=%r' % (key, value)
13215 
      for key, value in self.__dict__.iteritems()]
13216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13217 
 
13218 
  def __eq__(self, other):
13219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13220 
 
13221 
  def __ne__(self, other):
13222 
    return not (self == other)
13223 
 
2981 rajveer 13224 
class getAllUsers_args:
94 ashish 13225 
  """
13226 
  Attributes:
2981 rajveer 13227 
   - userType
13228 
   - startDate
13229 
   - endDate
94 ashish 13230 
  """
13231 
 
13232 
  thrift_spec = (
13233 
    None, # 0
2981 rajveer 13234 
    (1, TType.I32, 'userType', None, None, ), # 1
13235 
    (2, TType.I64, 'startDate', None, None, ), # 2
13236 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 13237 
  )
13238 
 
2981 rajveer 13239 
  def __init__(self, userType=None, startDate=None, endDate=None,):
13240 
    self.userType = userType
13241 
    self.startDate = startDate
13242 
    self.endDate = endDate
94 ashish 13243 
 
13244 
  def read(self, iprot):
13245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13247 
      return
13248 
    iprot.readStructBegin()
13249 
    while True:
13250 
      (fname, ftype, fid) = iprot.readFieldBegin()
13251 
      if ftype == TType.STOP:
13252 
        break
13253 
      if fid == 1:
2981 rajveer 13254 
        if ftype == TType.I32:
13255 
          self.userType = iprot.readI32();
94 ashish 13256 
        else:
13257 
          iprot.skip(ftype)
13258 
      elif fid == 2:
559 chandransh 13259 
        if ftype == TType.I64:
2981 rajveer 13260 
          self.startDate = iprot.readI64();
94 ashish 13261 
        else:
13262 
          iprot.skip(ftype)
2981 rajveer 13263 
      elif fid == 3:
13264 
        if ftype == TType.I64:
13265 
          self.endDate = iprot.readI64();
13266 
        else:
13267 
          iprot.skip(ftype)
94 ashish 13268 
      else:
13269 
        iprot.skip(ftype)
13270 
      iprot.readFieldEnd()
13271 
    iprot.readStructEnd()
13272 
 
13273 
  def write(self, oprot):
13274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13276 
      return
2981 rajveer 13277 
    oprot.writeStructBegin('getAllUsers_args')
3431 rajveer 13278 
    if self.userType is not None:
2981 rajveer 13279 
      oprot.writeFieldBegin('userType', TType.I32, 1)
13280 
      oprot.writeI32(self.userType)
94 ashish 13281 
      oprot.writeFieldEnd()
3431 rajveer 13282 
    if self.startDate is not None:
2981 rajveer 13283 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
13284 
      oprot.writeI64(self.startDate)
94 ashish 13285 
      oprot.writeFieldEnd()
3431 rajveer 13286 
    if self.endDate is not None:
2981 rajveer 13287 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
13288 
      oprot.writeI64(self.endDate)
13289 
      oprot.writeFieldEnd()
94 ashish 13290 
    oprot.writeFieldStop()
13291 
    oprot.writeStructEnd()
13292 
 
3431 rajveer 13293 
  def validate(self):
13294 
    return
13295 
 
13296 
 
94 ashish 13297 
  def __repr__(self):
13298 
    L = ['%s=%r' % (key, value)
13299 
      for key, value in self.__dict__.iteritems()]
13300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13301 
 
13302 
  def __eq__(self, other):
13303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13304 
 
13305 
  def __ne__(self, other):
13306 
    return not (self == other)
13307 
 
2981 rajveer 13308 
class getAllUsers_result:
94 ashish 13309 
  """
13310 
  Attributes:
13311 
   - success
13312 
  """
13313 
 
13314 
  thrift_spec = (
2981 rajveer 13315 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 13316 
  )
13317 
 
2981 rajveer 13318 
  def __init__(self, success=None,):
94 ashish 13319 
    self.success = success
13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      if fid == 0:
2981 rajveer 13331 
        if ftype == TType.LIST:
13332 
          self.success = []
11980 amit.gupta 13333 
          (_etype193, _size190) = iprot.readListBegin()
13334 
          for _i194 in xrange(_size190):
13335 
            _elem195 = User()
13336 
            _elem195.read(iprot)
13337 
            self.success.append(_elem195)
2981 rajveer 13338 
          iprot.readListEnd()
94 ashish 13339 
        else:
13340 
          iprot.skip(ftype)
13341 
      else:
13342 
        iprot.skip(ftype)
13343 
      iprot.readFieldEnd()
13344 
    iprot.readStructEnd()
13345 
 
13346 
  def write(self, oprot):
13347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13349 
      return
2981 rajveer 13350 
    oprot.writeStructBegin('getAllUsers_result')
3431 rajveer 13351 
    if self.success is not None:
2981 rajveer 13352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13353 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11980 amit.gupta 13354 
      for iter196 in self.success:
13355 
        iter196.write(oprot)
2981 rajveer 13356 
      oprot.writeListEnd()
94 ashish 13357 
      oprot.writeFieldEnd()
13358 
    oprot.writeFieldStop()
13359 
    oprot.writeStructEnd()
13360 
 
3431 rajveer 13361 
  def validate(self):
13362 
    return
13363 
 
13364 
 
94 ashish 13365 
  def __repr__(self):
13366 
    L = ['%s=%r' % (key, value)
13367 
      for key, value in self.__dict__.iteritems()]
13368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13369 
 
13370 
  def __eq__(self, other):
13371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13372 
 
13373 
  def __ne__(self, other):
13374 
    return not (self == other)
13375 
 
2981 rajveer 13376 
class getMyResearchItems_args:
559 chandransh 13377 
  """
13378 
  Attributes:
772 rajveer 13379 
   - userId
559 chandransh 13380 
  """
13381 
 
13382 
  thrift_spec = (
13383 
    None, # 0
772 rajveer 13384 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 13385 
  )
13386 
 
772 rajveer 13387 
  def __init__(self, userId=None,):
13388 
    self.userId = userId
559 chandransh 13389 
 
13390 
  def read(self, iprot):
13391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13393 
      return
13394 
    iprot.readStructBegin()
13395 
    while True:
13396 
      (fname, ftype, fid) = iprot.readFieldBegin()
13397 
      if ftype == TType.STOP:
13398 
        break
13399 
      if fid == 1:
13400 
        if ftype == TType.I64:
772 rajveer 13401 
          self.userId = iprot.readI64();
559 chandransh 13402 
        else:
13403 
          iprot.skip(ftype)
13404 
      else:
13405 
        iprot.skip(ftype)
13406 
      iprot.readFieldEnd()
13407 
    iprot.readStructEnd()
13408 
 
13409 
  def write(self, oprot):
13410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13412 
      return
2981 rajveer 13413 
    oprot.writeStructBegin('getMyResearchItems_args')
3431 rajveer 13414 
    if self.userId is not None:
772 rajveer 13415 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13416 
      oprot.writeI64(self.userId)
559 chandransh 13417 
      oprot.writeFieldEnd()
13418 
    oprot.writeFieldStop()
13419 
    oprot.writeStructEnd()
13420 
 
3431 rajveer 13421 
  def validate(self):
13422 
    return
13423 
 
13424 
 
559 chandransh 13425 
  def __repr__(self):
13426 
    L = ['%s=%r' % (key, value)
13427 
      for key, value in self.__dict__.iteritems()]
13428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13429 
 
13430 
  def __eq__(self, other):
13431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13432 
 
13433 
  def __ne__(self, other):
13434 
    return not (self == other)
13435 
 
2981 rajveer 13436 
class getMyResearchItems_result:
559 chandransh 13437 
  """
13438 
  Attributes:
130 ashish 13439 
   - success
559 chandransh 13440 
   - scx
130 ashish 13441 
  """
13442 
 
13443 
  thrift_spec = (
2981 rajveer 13444 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 13445 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 13446 
  )
13447 
 
559 chandransh 13448 
  def __init__(self, success=None, scx=None,):
130 ashish 13449 
    self.success = success
559 chandransh 13450 
    self.scx = scx
130 ashish 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
13461 
      if fid == 0:
2981 rajveer 13462 
        if ftype == TType.LIST:
13463 
          self.success = []
11980 amit.gupta 13464 
          (_etype200, _size197) = iprot.readListBegin()
13465 
          for _i201 in xrange(_size197):
13466 
            _elem202 = iprot.readI64();
13467 
            self.success.append(_elem202)
2981 rajveer 13468 
          iprot.readListEnd()
130 ashish 13469 
        else:
13470 
          iprot.skip(ftype)
13471 
      elif fid == 1:
13472 
        if ftype == TType.STRUCT:
559 chandransh 13473 
          self.scx = WidgetException()
13474 
          self.scx.read(iprot)
130 ashish 13475 
        else:
13476 
          iprot.skip(ftype)
13477 
      else:
13478 
        iprot.skip(ftype)
13479 
      iprot.readFieldEnd()
13480 
    iprot.readStructEnd()
13481 
 
13482 
  def write(self, oprot):
13483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13485 
      return
2981 rajveer 13486 
    oprot.writeStructBegin('getMyResearchItems_result')
3431 rajveer 13487 
    if self.success is not None:
2981 rajveer 13488 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13489 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13490 
      for iter203 in self.success:
13491 
        oprot.writeI64(iter203)
2981 rajveer 13492 
      oprot.writeListEnd()
130 ashish 13493 
      oprot.writeFieldEnd()
3431 rajveer 13494 
    if self.scx is not None:
559 chandransh 13495 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13496 
      self.scx.write(oprot)
130 ashish 13497 
      oprot.writeFieldEnd()
13498 
    oprot.writeFieldStop()
13499 
    oprot.writeStructEnd()
13500 
 
3431 rajveer 13501 
  def validate(self):
13502 
    return
13503 
 
13504 
 
130 ashish 13505 
  def __repr__(self):
13506 
    L = ['%s=%r' % (key, value)
13507 
      for key, value in self.__dict__.iteritems()]
13508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13509 
 
13510 
  def __eq__(self, other):
13511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13512 
 
13513 
  def __ne__(self, other):
13514 
    return not (self == other)
13515 
 
2981 rajveer 13516 
class updateMyResearch_args:
130 ashish 13517 
  """
13518 
  Attributes:
2981 rajveer 13519 
   - userId
13520 
   - itemId
130 ashish 13521 
  """
13522 
 
13523 
  thrift_spec = (
13524 
    None, # 0
2981 rajveer 13525 
    (1, TType.I64, 'userId', None, None, ), # 1
13526 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 13527 
  )
13528 
 
2981 rajveer 13529 
  def __init__(self, userId=None, itemId=None,):
13530 
    self.userId = userId
13531 
    self.itemId = itemId
130 ashish 13532 
 
13533 
  def read(self, iprot):
13534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13536 
      return
13537 
    iprot.readStructBegin()
13538 
    while True:
13539 
      (fname, ftype, fid) = iprot.readFieldBegin()
13540 
      if ftype == TType.STOP:
13541 
        break
13542 
      if fid == 1:
559 chandransh 13543 
        if ftype == TType.I64:
2981 rajveer 13544 
          self.userId = iprot.readI64();
130 ashish 13545 
        else:
13546 
          iprot.skip(ftype)
13547 
      elif fid == 2:
559 chandransh 13548 
        if ftype == TType.I64:
2981 rajveer 13549 
          self.itemId = iprot.readI64();
559 chandransh 13550 
        else:
13551 
          iprot.skip(ftype)
130 ashish 13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
2981 rajveer 13561 
    oprot.writeStructBegin('updateMyResearch_args')
3431 rajveer 13562 
    if self.userId is not None:
2981 rajveer 13563 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13564 
      oprot.writeI64(self.userId)
130 ashish 13565 
      oprot.writeFieldEnd()
3431 rajveer 13566 
    if self.itemId is not None:
2981 rajveer 13567 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13568 
      oprot.writeI64(self.itemId)
130 ashish 13569 
      oprot.writeFieldEnd()
13570 
    oprot.writeFieldStop()
13571 
    oprot.writeStructEnd()
13572 
 
3431 rajveer 13573 
  def validate(self):
13574 
    return
13575 
 
13576 
 
130 ashish 13577 
  def __repr__(self):
13578 
    L = ['%s=%r' % (key, value)
13579 
      for key, value in self.__dict__.iteritems()]
13580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13581 
 
13582 
  def __eq__(self, other):
13583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13584 
 
13585 
  def __ne__(self, other):
13586 
    return not (self == other)
13587 
 
2981 rajveer 13588 
class updateMyResearch_result:
13589 
  """
13590 
  Attributes:
13591 
   - success
13592 
   - scx
13593 
  """
559 chandransh 13594 
 
13595 
  thrift_spec = (
2981 rajveer 13596 
    (0, TType.BOOL, 'success', None, None, ), # 0
13597 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 13598 
  )
13599 
 
2981 rajveer 13600 
  def __init__(self, success=None, scx=None,):
13601 
    self.success = success
13602 
    self.scx = scx
13603 
 
559 chandransh 13604 
  def read(self, iprot):
13605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13607 
      return
13608 
    iprot.readStructBegin()
13609 
    while True:
13610 
      (fname, ftype, fid) = iprot.readFieldBegin()
13611 
      if ftype == TType.STOP:
13612 
        break
2981 rajveer 13613 
      if fid == 0:
13614 
        if ftype == TType.BOOL:
13615 
          self.success = iprot.readBool();
13616 
        else:
13617 
          iprot.skip(ftype)
13618 
      elif fid == 1:
13619 
        if ftype == TType.STRUCT:
13620 
          self.scx = WidgetException()
13621 
          self.scx.read(iprot)
13622 
        else:
13623 
          iprot.skip(ftype)
559 chandransh 13624 
      else:
13625 
        iprot.skip(ftype)
13626 
      iprot.readFieldEnd()
13627 
    iprot.readStructEnd()
13628 
 
13629 
  def write(self, oprot):
13630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13632 
      return
2981 rajveer 13633 
    oprot.writeStructBegin('updateMyResearch_result')
3431 rajveer 13634 
    if self.success is not None:
2981 rajveer 13635 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13636 
      oprot.writeBool(self.success)
13637 
      oprot.writeFieldEnd()
3431 rajveer 13638 
    if self.scx is not None:
2981 rajveer 13639 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13640 
      self.scx.write(oprot)
13641 
      oprot.writeFieldEnd()
559 chandransh 13642 
    oprot.writeFieldStop()
13643 
    oprot.writeStructEnd()
13644 
 
3431 rajveer 13645 
  def validate(self):
13646 
    return
13647 
 
13648 
 
559 chandransh 13649 
  def __repr__(self):
13650 
    L = ['%s=%r' % (key, value)
13651 
      for key, value in self.__dict__.iteritems()]
13652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13653 
 
13654 
  def __eq__(self, other):
13655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13656 
 
13657 
  def __ne__(self, other):
13658 
    return not (self == other)
13659 
 
2981 rajveer 13660 
class deleteItemFromMyResearch_args:
1596 ankur.sing 13661 
  """
13662 
  Attributes:
2981 rajveer 13663 
   - userId
13664 
   - itemId
1596 ankur.sing 13665 
  """
559 chandransh 13666 
 
1596 ankur.sing 13667 
  thrift_spec = (
13668 
    None, # 0
2981 rajveer 13669 
    (1, TType.I64, 'userId', None, None, ), # 1
13670 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 13671 
  )
13672 
 
2981 rajveer 13673 
  def __init__(self, userId=None, itemId=None,):
13674 
    self.userId = userId
13675 
    self.itemId = itemId
1596 ankur.sing 13676 
 
13677 
  def read(self, iprot):
13678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13680 
      return
13681 
    iprot.readStructBegin()
13682 
    while True:
13683 
      (fname, ftype, fid) = iprot.readFieldBegin()
13684 
      if ftype == TType.STOP:
13685 
        break
13686 
      if fid == 1:
2981 rajveer 13687 
        if ftype == TType.I64:
13688 
          self.userId = iprot.readI64();
1596 ankur.sing 13689 
        else:
13690 
          iprot.skip(ftype)
2981 rajveer 13691 
      elif fid == 2:
13692 
        if ftype == TType.I64:
13693 
          self.itemId = iprot.readI64();
13694 
        else:
13695 
          iprot.skip(ftype)
1596 ankur.sing 13696 
      else:
13697 
        iprot.skip(ftype)
13698 
      iprot.readFieldEnd()
13699 
    iprot.readStructEnd()
13700 
 
13701 
  def write(self, oprot):
13702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13704 
      return
2981 rajveer 13705 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
3431 rajveer 13706 
    if self.userId is not None:
2981 rajveer 13707 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13708 
      oprot.writeI64(self.userId)
1596 ankur.sing 13709 
      oprot.writeFieldEnd()
3431 rajveer 13710 
    if self.itemId is not None:
2981 rajveer 13711 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13712 
      oprot.writeI64(self.itemId)
13713 
      oprot.writeFieldEnd()
1596 ankur.sing 13714 
    oprot.writeFieldStop()
13715 
    oprot.writeStructEnd()
13716 
 
3431 rajveer 13717 
  def validate(self):
13718 
    return
13719 
 
13720 
 
1596 ankur.sing 13721 
  def __repr__(self):
13722 
    L = ['%s=%r' % (key, value)
13723 
      for key, value in self.__dict__.iteritems()]
13724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13725 
 
13726 
  def __eq__(self, other):
13727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13728 
 
13729 
  def __ne__(self, other):
13730 
    return not (self == other)
13731 
 
2981 rajveer 13732 
class deleteItemFromMyResearch_result:
1596 ankur.sing 13733 
  """
13734 
  Attributes:
2981 rajveer 13735 
   - scx
1596 ankur.sing 13736 
  """
13737 
 
13738 
  thrift_spec = (
2981 rajveer 13739 
    None, # 0
13740 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 13741 
  )
13742 
 
2981 rajveer 13743 
  def __init__(self, scx=None,):
13744 
    self.scx = scx
1596 ankur.sing 13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
2981 rajveer 13755 
      if fid == 1:
13756 
        if ftype == TType.STRUCT:
13757 
          self.scx = WidgetException()
13758 
          self.scx.read(iprot)
1596 ankur.sing 13759 
        else:
13760 
          iprot.skip(ftype)
13761 
      else:
13762 
        iprot.skip(ftype)
13763 
      iprot.readFieldEnd()
13764 
    iprot.readStructEnd()
13765 
 
13766 
  def write(self, oprot):
13767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13769 
      return
2981 rajveer 13770 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
3431 rajveer 13771 
    if self.scx is not None:
2981 rajveer 13772 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13773 
      self.scx.write(oprot)
1596 ankur.sing 13774 
      oprot.writeFieldEnd()
13775 
    oprot.writeFieldStop()
13776 
    oprot.writeStructEnd()
13777 
 
3431 rajveer 13778 
  def validate(self):
13779 
    return
13780 
 
13781 
 
1596 ankur.sing 13782 
  def __repr__(self):
13783 
    L = ['%s=%r' % (key, value)
13784 
      for key, value in self.__dict__.iteritems()]
13785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13786 
 
13787 
  def __eq__(self, other):
13788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13789 
 
13790 
  def __ne__(self, other):
13791 
    return not (self == other)
13792 
 
2981 rajveer 13793 
class getBrowseHistoryItems_args:
1673 ankur.sing 13794 
  """
13795 
  Attributes:
2981 rajveer 13796 
   - userId
1673 ankur.sing 13797 
  """
1596 ankur.sing 13798 
 
1673 ankur.sing 13799 
  thrift_spec = (
13800 
    None, # 0
2981 rajveer 13801 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 13802 
  )
13803 
 
2981 rajveer 13804 
  def __init__(self, userId=None,):
13805 
    self.userId = userId
1673 ankur.sing 13806 
 
13807 
  def read(self, iprot):
13808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13810 
      return
13811 
    iprot.readStructBegin()
13812 
    while True:
13813 
      (fname, ftype, fid) = iprot.readFieldBegin()
13814 
      if ftype == TType.STOP:
13815 
        break
13816 
      if fid == 1:
1891 ankur.sing 13817 
        if ftype == TType.I64:
2981 rajveer 13818 
          self.userId = iprot.readI64();
1891 ankur.sing 13819 
        else:
13820 
          iprot.skip(ftype)
1673 ankur.sing 13821 
      else:
13822 
        iprot.skip(ftype)
13823 
      iprot.readFieldEnd()
13824 
    iprot.readStructEnd()
13825 
 
13826 
  def write(self, oprot):
13827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13829 
      return
2981 rajveer 13830 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
3431 rajveer 13831 
    if self.userId is not None:
2981 rajveer 13832 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13833 
      oprot.writeI64(self.userId)
1673 ankur.sing 13834 
      oprot.writeFieldEnd()
13835 
    oprot.writeFieldStop()
13836 
    oprot.writeStructEnd()
13837 
 
3431 rajveer 13838 
  def validate(self):
13839 
    return
13840 
 
13841 
 
1673 ankur.sing 13842 
  def __repr__(self):
13843 
    L = ['%s=%r' % (key, value)
13844 
      for key, value in self.__dict__.iteritems()]
13845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13846 
 
13847 
  def __eq__(self, other):
13848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13849 
 
13850 
  def __ne__(self, other):
13851 
    return not (self == other)
13852 
 
2981 rajveer 13853 
class getBrowseHistoryItems_result:
1673 ankur.sing 13854 
  """
13855 
  Attributes:
13856 
   - success
2981 rajveer 13857 
   - scx
1673 ankur.sing 13858 
  """
13859 
 
13860 
  thrift_spec = (
2981 rajveer 13861 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13862 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 13863 
  )
13864 
 
2981 rajveer 13865 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 13866 
    self.success = success
2981 rajveer 13867 
    self.scx = scx
1673 ankur.sing 13868 
 
13869 
  def read(self, iprot):
13870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13872 
      return
13873 
    iprot.readStructBegin()
13874 
    while True:
13875 
      (fname, ftype, fid) = iprot.readFieldBegin()
13876 
      if ftype == TType.STOP:
13877 
        break
13878 
      if fid == 0:
13879 
        if ftype == TType.LIST:
13880 
          self.success = []
11980 amit.gupta 13881 
          (_etype207, _size204) = iprot.readListBegin()
13882 
          for _i208 in xrange(_size204):
13883 
            _elem209 = iprot.readI64();
13884 
            self.success.append(_elem209)
1673 ankur.sing 13885 
          iprot.readListEnd()
13886 
        else:
13887 
          iprot.skip(ftype)
2981 rajveer 13888 
      elif fid == 1:
13889 
        if ftype == TType.STRUCT:
13890 
          self.scx = WidgetException()
13891 
          self.scx.read(iprot)
13892 
        else:
13893 
          iprot.skip(ftype)
1673 ankur.sing 13894 
      else:
13895 
        iprot.skip(ftype)
13896 
      iprot.readFieldEnd()
13897 
    iprot.readStructEnd()
13898 
 
13899 
  def write(self, oprot):
13900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13902 
      return
2981 rajveer 13903 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
3431 rajveer 13904 
    if self.success is not None:
1673 ankur.sing 13905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 13906 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 13907 
      for iter210 in self.success:
13908 
        oprot.writeI64(iter210)
1673 ankur.sing 13909 
      oprot.writeListEnd()
13910 
      oprot.writeFieldEnd()
3431 rajveer 13911 
    if self.scx is not None:
2981 rajveer 13912 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
13913 
      self.scx.write(oprot)
2642 varun.gupt 13914 
      oprot.writeFieldEnd()
13915 
    oprot.writeFieldStop()
13916 
    oprot.writeStructEnd()
13917 
 
3431 rajveer 13918 
  def validate(self):
13919 
    return
13920 
 
13921 
 
2642 varun.gupt 13922 
  def __repr__(self):
13923 
    L = ['%s=%r' % (key, value)
13924 
      for key, value in self.__dict__.iteritems()]
13925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13926 
 
13927 
  def __eq__(self, other):
13928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13929 
 
13930 
  def __ne__(self, other):
13931 
    return not (self == other)
13932 
 
2981 rajveer 13933 
class updateBrowseHistory_args:
2642 varun.gupt 13934 
  """
13935 
  Attributes:
2981 rajveer 13936 
   - userId
13937 
   - itemId
2642 varun.gupt 13938 
  """
13939 
 
13940 
  thrift_spec = (
13941 
    None, # 0
2981 rajveer 13942 
    (1, TType.I64, 'userId', None, None, ), # 1
13943 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 13944 
  )
13945 
 
2981 rajveer 13946 
  def __init__(self, userId=None, itemId=None,):
13947 
    self.userId = userId
13948 
    self.itemId = itemId
2642 varun.gupt 13949 
 
13950 
  def read(self, iprot):
13951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13953 
      return
13954 
    iprot.readStructBegin()
13955 
    while True:
13956 
      (fname, ftype, fid) = iprot.readFieldBegin()
13957 
      if ftype == TType.STOP:
13958 
        break
13959 
      if fid == 1:
13960 
        if ftype == TType.I64:
2981 rajveer 13961 
          self.userId = iprot.readI64();
2642 varun.gupt 13962 
        else:
13963 
          iprot.skip(ftype)
13964 
      elif fid == 2:
13965 
        if ftype == TType.I64:
2981 rajveer 13966 
          self.itemId = iprot.readI64();
2642 varun.gupt 13967 
        else:
13968 
          iprot.skip(ftype)
13969 
      else:
13970 
        iprot.skip(ftype)
13971 
      iprot.readFieldEnd()
13972 
    iprot.readStructEnd()
13973 
 
13974 
  def write(self, oprot):
13975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13977 
      return
2981 rajveer 13978 
    oprot.writeStructBegin('updateBrowseHistory_args')
3431 rajveer 13979 
    if self.userId is not None:
2981 rajveer 13980 
      oprot.writeFieldBegin('userId', TType.I64, 1)
13981 
      oprot.writeI64(self.userId)
2642 varun.gupt 13982 
      oprot.writeFieldEnd()
3431 rajveer 13983 
    if self.itemId is not None:
2981 rajveer 13984 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13985 
      oprot.writeI64(self.itemId)
2642 varun.gupt 13986 
      oprot.writeFieldEnd()
13987 
    oprot.writeFieldStop()
13988 
    oprot.writeStructEnd()
13989 
 
3431 rajveer 13990 
  def validate(self):
13991 
    return
13992 
 
13993 
 
2642 varun.gupt 13994 
  def __repr__(self):
13995 
    L = ['%s=%r' % (key, value)
13996 
      for key, value in self.__dict__.iteritems()]
13997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13998 
 
13999 
  def __eq__(self, other):
14000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14001 
 
14002 
  def __ne__(self, other):
14003 
    return not (self == other)
14004 
 
2981 rajveer 14005 
class updateBrowseHistory_result:
2642 varun.gupt 14006 
 
14007 
  thrift_spec = (
14008 
  )
14009 
 
14010 
  def read(self, iprot):
14011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14013 
      return
14014 
    iprot.readStructBegin()
14015 
    while True:
14016 
      (fname, ftype, fid) = iprot.readFieldBegin()
14017 
      if ftype == TType.STOP:
14018 
        break
14019 
      else:
14020 
        iprot.skip(ftype)
14021 
      iprot.readFieldEnd()
14022 
    iprot.readStructEnd()
14023 
 
14024 
  def write(self, oprot):
14025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14027 
      return
2981 rajveer 14028 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 14029 
    oprot.writeFieldStop()
14030 
    oprot.writeStructEnd()
14031 
 
3431 rajveer 14032 
  def validate(self):
14033 
    return
14034 
 
14035 
 
2642 varun.gupt 14036 
  def __repr__(self):
14037 
    L = ['%s=%r' % (key, value)
14038 
      for key, value in self.__dict__.iteritems()]
14039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14040 
 
14041 
  def __eq__(self, other):
14042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14043 
 
14044 
  def __ne__(self, other):
14045 
    return not (self == other)
14046 
 
3385 varun.gupt 14047 
class getCartsWithCouponCount_args:
14048 
  """
14049 
  Attributes:
14050 
   - couponCode
14051 
  """
2642 varun.gupt 14052 
 
3385 varun.gupt 14053 
  thrift_spec = (
14054 
    None, # 0
14055 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
14056 
  )
14057 
 
14058 
  def __init__(self, couponCode=None,):
14059 
    self.couponCode = couponCode
14060 
 
14061 
  def read(self, iprot):
14062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14064 
      return
14065 
    iprot.readStructBegin()
14066 
    while True:
14067 
      (fname, ftype, fid) = iprot.readFieldBegin()
14068 
      if ftype == TType.STOP:
14069 
        break
14070 
      if fid == 1:
14071 
        if ftype == TType.STRING:
14072 
          self.couponCode = iprot.readString();
14073 
        else:
14074 
          iprot.skip(ftype)
14075 
      else:
14076 
        iprot.skip(ftype)
14077 
      iprot.readFieldEnd()
14078 
    iprot.readStructEnd()
14079 
 
14080 
  def write(self, oprot):
14081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14083 
      return
14084 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
3431 rajveer 14085 
    if self.couponCode is not None:
3385 varun.gupt 14086 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
14087 
      oprot.writeString(self.couponCode)
14088 
      oprot.writeFieldEnd()
14089 
    oprot.writeFieldStop()
14090 
    oprot.writeStructEnd()
14091 
 
3431 rajveer 14092 
  def validate(self):
14093 
    return
14094 
 
14095 
 
3385 varun.gupt 14096 
  def __repr__(self):
14097 
    L = ['%s=%r' % (key, value)
14098 
      for key, value in self.__dict__.iteritems()]
14099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14100 
 
14101 
  def __eq__(self, other):
14102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14103 
 
14104 
  def __ne__(self, other):
14105 
    return not (self == other)
14106 
 
14107 
class getCartsWithCouponCount_result:
14108 
  """
14109 
  Attributes:
14110 
   - success
14111 
  """
14112 
 
14113 
  thrift_spec = (
14114 
    (0, TType.I64, 'success', None, None, ), # 0
14115 
  )
14116 
 
14117 
  def __init__(self, success=None,):
14118 
    self.success = success
14119 
 
14120 
  def read(self, iprot):
14121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14123 
      return
14124 
    iprot.readStructBegin()
14125 
    while True:
14126 
      (fname, ftype, fid) = iprot.readFieldBegin()
14127 
      if ftype == TType.STOP:
14128 
        break
14129 
      if fid == 0:
14130 
        if ftype == TType.I64:
14131 
          self.success = iprot.readI64();
14132 
        else:
14133 
          iprot.skip(ftype)
14134 
      else:
14135 
        iprot.skip(ftype)
14136 
      iprot.readFieldEnd()
14137 
    iprot.readStructEnd()
14138 
 
14139 
  def write(self, oprot):
14140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14142 
      return
14143 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
3431 rajveer 14144 
    if self.success is not None:
3385 varun.gupt 14145 
      oprot.writeFieldBegin('success', TType.I64, 0)
14146 
      oprot.writeI64(self.success)
14147 
      oprot.writeFieldEnd()
14148 
    oprot.writeFieldStop()
14149 
    oprot.writeStructEnd()
14150 
 
3431 rajveer 14151 
  def validate(self):
14152 
    return
14153 
 
14154 
 
3385 varun.gupt 14155 
  def __repr__(self):
14156 
    L = ['%s=%r' % (key, value)
14157 
      for key, value in self.__dict__.iteritems()]
14158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14159 
 
14160 
  def __eq__(self, other):
14161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14162 
 
14163 
  def __ne__(self, other):
14164 
    return not (self == other)
3499 mandeep.dh 14165 
 
14166 
class increaseTrustLevel_args:
14167 
  """
14168 
  Attributes:
14169 
   - userId
14170 
   - trustLevelDelta
14171 
  """
14172 
 
14173 
  thrift_spec = (
14174 
    None, # 0
14175 
    (1, TType.I64, 'userId', None, None, ), # 1
14176 
    (2, TType.DOUBLE, 'trustLevelDelta', None, None, ), # 2
14177 
  )
14178 
 
14179 
  def __init__(self, userId=None, trustLevelDelta=None,):
14180 
    self.userId = userId
14181 
    self.trustLevelDelta = trustLevelDelta
14182 
 
14183 
  def read(self, iprot):
14184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14186 
      return
14187 
    iprot.readStructBegin()
14188 
    while True:
14189 
      (fname, ftype, fid) = iprot.readFieldBegin()
14190 
      if ftype == TType.STOP:
14191 
        break
14192 
      if fid == 1:
14193 
        if ftype == TType.I64:
14194 
          self.userId = iprot.readI64();
14195 
        else:
14196 
          iprot.skip(ftype)
14197 
      elif fid == 2:
14198 
        if ftype == TType.DOUBLE:
14199 
          self.trustLevelDelta = iprot.readDouble();
14200 
        else:
14201 
          iprot.skip(ftype)
14202 
      else:
14203 
        iprot.skip(ftype)
14204 
      iprot.readFieldEnd()
14205 
    iprot.readStructEnd()
14206 
 
14207 
  def write(self, oprot):
14208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14210 
      return
14211 
    oprot.writeStructBegin('increaseTrustLevel_args')
14212 
    if self.userId is not None:
14213 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14214 
      oprot.writeI64(self.userId)
14215 
      oprot.writeFieldEnd()
14216 
    if self.trustLevelDelta is not None:
14217 
      oprot.writeFieldBegin('trustLevelDelta', TType.DOUBLE, 2)
14218 
      oprot.writeDouble(self.trustLevelDelta)
14219 
      oprot.writeFieldEnd()
14220 
    oprot.writeFieldStop()
14221 
    oprot.writeStructEnd()
14222 
 
14223 
  def validate(self):
14224 
    return
14225 
 
14226 
 
14227 
  def __repr__(self):
14228 
    L = ['%s=%r' % (key, value)
14229 
      for key, value in self.__dict__.iteritems()]
14230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14231 
 
14232 
  def __eq__(self, other):
14233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14234 
 
14235 
  def __ne__(self, other):
14236 
    return not (self == other)
4668 varun.gupt 14237 
 
5407 amar.kumar 14238 
class getTrustLevel_args:
14239 
  """
14240 
  Attributes:
14241 
   - userId
14242 
  """
14243 
 
14244 
  thrift_spec = (
14245 
    None, # 0
14246 
    (1, TType.I64, 'userId', None, None, ), # 1
14247 
  )
14248 
 
14249 
  def __init__(self, userId=None,):
14250 
    self.userId = userId
14251 
 
14252 
  def read(self, iprot):
14253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14255 
      return
14256 
    iprot.readStructBegin()
14257 
    while True:
14258 
      (fname, ftype, fid) = iprot.readFieldBegin()
14259 
      if ftype == TType.STOP:
14260 
        break
14261 
      if fid == 1:
14262 
        if ftype == TType.I64:
14263 
          self.userId = iprot.readI64();
14264 
        else:
14265 
          iprot.skip(ftype)
14266 
      else:
14267 
        iprot.skip(ftype)
14268 
      iprot.readFieldEnd()
14269 
    iprot.readStructEnd()
14270 
 
14271 
  def write(self, oprot):
14272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14274 
      return
14275 
    oprot.writeStructBegin('getTrustLevel_args')
14276 
    if self.userId is not None:
14277 
      oprot.writeFieldBegin('userId', TType.I64, 1)
14278 
      oprot.writeI64(self.userId)
14279 
      oprot.writeFieldEnd()
14280 
    oprot.writeFieldStop()
14281 
    oprot.writeStructEnd()
14282 
 
14283 
  def validate(self):
14284 
    return
14285 
 
14286 
 
14287 
  def __repr__(self):
14288 
    L = ['%s=%r' % (key, value)
14289 
      for key, value in self.__dict__.iteritems()]
14290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14291 
 
14292 
  def __eq__(self, other):
14293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14294 
 
14295 
  def __ne__(self, other):
14296 
    return not (self == other)
14297 
 
14298 
class getTrustLevel_result:
14299 
  """
14300 
  Attributes:
14301 
   - success
14302 
  """
14303 
 
14304 
  thrift_spec = (
14305 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14306 
  )
14307 
 
14308 
  def __init__(self, success=None,):
14309 
    self.success = success
14310 
 
14311 
  def read(self, iprot):
14312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14314 
      return
14315 
    iprot.readStructBegin()
14316 
    while True:
14317 
      (fname, ftype, fid) = iprot.readFieldBegin()
14318 
      if ftype == TType.STOP:
14319 
        break
14320 
      if fid == 0:
14321 
        if ftype == TType.DOUBLE:
14322 
          self.success = iprot.readDouble();
14323 
        else:
14324 
          iprot.skip(ftype)
14325 
      else:
14326 
        iprot.skip(ftype)
14327 
      iprot.readFieldEnd()
14328 
    iprot.readStructEnd()
14329 
 
14330 
  def write(self, oprot):
14331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14333 
      return
14334 
    oprot.writeStructBegin('getTrustLevel_result')
14335 
    if self.success is not None:
14336 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14337 
      oprot.writeDouble(self.success)
14338 
      oprot.writeFieldEnd()
14339 
    oprot.writeFieldStop()
14340 
    oprot.writeStructEnd()
14341 
 
14342 
  def validate(self):
14343 
    return
14344 
 
14345 
 
14346 
  def __repr__(self):
14347 
    L = ['%s=%r' % (key, value)
14348 
      for key, value in self.__dict__.iteritems()]
14349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14350 
 
14351 
  def __eq__(self, other):
14352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14353 
 
14354 
  def __ne__(self, other):
14355 
    return not (self == other)
14356 
 
4668 varun.gupt 14357 
class showCODOption_args:
14358 
  """
14359 
  Attributes:
14360 
   - cartId
14361 
   - sourceId
14362 
   - pincode
14363 
  """
14364 
 
14365 
  thrift_spec = (
14366 
    None, # 0
14367 
    (1, TType.I64, 'cartId', None, None, ), # 1
14368 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14369 
    (3, TType.STRING, 'pincode', None, None, ), # 3
14370 
  )
14371 
 
14372 
  def __init__(self, cartId=None, sourceId=None, pincode=None,):
14373 
    self.cartId = cartId
14374 
    self.sourceId = sourceId
14375 
    self.pincode = pincode
14376 
 
14377 
  def read(self, iprot):
14378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14380 
      return
14381 
    iprot.readStructBegin()
14382 
    while True:
14383 
      (fname, ftype, fid) = iprot.readFieldBegin()
14384 
      if ftype == TType.STOP:
14385 
        break
14386 
      if fid == 1:
14387 
        if ftype == TType.I64:
14388 
          self.cartId = iprot.readI64();
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      elif fid == 2:
14392 
        if ftype == TType.I64:
14393 
          self.sourceId = iprot.readI64();
14394 
        else:
14395 
          iprot.skip(ftype)
14396 
      elif fid == 3:
14397 
        if ftype == TType.STRING:
14398 
          self.pincode = iprot.readString();
14399 
        else:
14400 
          iprot.skip(ftype)
14401 
      else:
14402 
        iprot.skip(ftype)
14403 
      iprot.readFieldEnd()
14404 
    iprot.readStructEnd()
14405 
 
14406 
  def write(self, oprot):
14407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14409 
      return
14410 
    oprot.writeStructBegin('showCODOption_args')
14411 
    if self.cartId is not None:
14412 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14413 
      oprot.writeI64(self.cartId)
14414 
      oprot.writeFieldEnd()
14415 
    if self.sourceId is not None:
14416 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14417 
      oprot.writeI64(self.sourceId)
14418 
      oprot.writeFieldEnd()
14419 
    if self.pincode is not None:
14420 
      oprot.writeFieldBegin('pincode', TType.STRING, 3)
14421 
      oprot.writeString(self.pincode)
14422 
      oprot.writeFieldEnd()
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 showCODOption_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('showCODOption_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)
5623 anupam.sin 14499 
 
14500 
class getUserEmails_args:
14501 
  """
14502 
  Attributes:
14503 
   - startDate
14504 
   - endDate
14505 
  """
14506 
 
14507 
  thrift_spec = (
14508 
    None, # 0
14509 
    (1, TType.I64, 'startDate', None, None, ), # 1
14510 
    (2, TType.I64, 'endDate', None, None, ), # 2
14511 
  )
14512 
 
14513 
  def __init__(self, startDate=None, endDate=None,):
14514 
    self.startDate = startDate
14515 
    self.endDate = endDate
14516 
 
14517 
  def read(self, iprot):
14518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14520 
      return
14521 
    iprot.readStructBegin()
14522 
    while True:
14523 
      (fname, ftype, fid) = iprot.readFieldBegin()
14524 
      if ftype == TType.STOP:
14525 
        break
14526 
      if fid == 1:
14527 
        if ftype == TType.I64:
14528 
          self.startDate = iprot.readI64();
14529 
        else:
14530 
          iprot.skip(ftype)
14531 
      elif fid == 2:
14532 
        if ftype == TType.I64:
14533 
          self.endDate = iprot.readI64();
14534 
        else:
14535 
          iprot.skip(ftype)
14536 
      else:
14537 
        iprot.skip(ftype)
14538 
      iprot.readFieldEnd()
14539 
    iprot.readStructEnd()
14540 
 
14541 
  def write(self, oprot):
14542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14544 
      return
14545 
    oprot.writeStructBegin('getUserEmails_args')
14546 
    if self.startDate is not None:
14547 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
14548 
      oprot.writeI64(self.startDate)
14549 
      oprot.writeFieldEnd()
14550 
    if self.endDate is not None:
14551 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
14552 
      oprot.writeI64(self.endDate)
14553 
      oprot.writeFieldEnd()
14554 
    oprot.writeFieldStop()
14555 
    oprot.writeStructEnd()
14556 
 
14557 
  def validate(self):
14558 
    return
14559 
 
14560 
 
14561 
  def __repr__(self):
14562 
    L = ['%s=%r' % (key, value)
14563 
      for key, value in self.__dict__.iteritems()]
14564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14565 
 
14566 
  def __eq__(self, other):
14567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14568 
 
14569 
  def __ne__(self, other):
14570 
    return not (self == other)
14571 
 
14572 
class getUserEmails_result:
14573 
  """
14574 
  Attributes:
14575 
   - success
14576 
  """
14577 
 
14578 
  thrift_spec = (
14579 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14580 
  )
14581 
 
14582 
  def __init__(self, success=None,):
14583 
    self.success = success
14584 
 
14585 
  def read(self, iprot):
14586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14588 
      return
14589 
    iprot.readStructBegin()
14590 
    while True:
14591 
      (fname, ftype, fid) = iprot.readFieldBegin()
14592 
      if ftype == TType.STOP:
14593 
        break
14594 
      if fid == 0:
14595 
        if ftype == TType.LIST:
14596 
          self.success = []
11980 amit.gupta 14597 
          (_etype214, _size211) = iprot.readListBegin()
14598 
          for _i215 in xrange(_size211):
14599 
            _elem216 = iprot.readString();
14600 
            self.success.append(_elem216)
5623 anupam.sin 14601 
          iprot.readListEnd()
14602 
        else:
14603 
          iprot.skip(ftype)
14604 
      else:
14605 
        iprot.skip(ftype)
14606 
      iprot.readFieldEnd()
14607 
    iprot.readStructEnd()
14608 
 
14609 
  def write(self, oprot):
14610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14612 
      return
14613 
    oprot.writeStructBegin('getUserEmails_result')
14614 
    if self.success is not None:
14615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14616 
      oprot.writeListBegin(TType.STRING, len(self.success))
11980 amit.gupta 14617 
      for iter217 in self.success:
14618 
        oprot.writeString(iter217)
5623 anupam.sin 14619 
      oprot.writeListEnd()
14620 
      oprot.writeFieldEnd()
14621 
    oprot.writeFieldStop()
14622 
    oprot.writeStructEnd()
14623 
 
14624 
  def validate(self):
14625 
    return
14626 
 
14627 
 
14628 
  def __repr__(self):
14629 
    L = ['%s=%r' % (key, value)
14630 
      for key, value in self.__dict__.iteritems()]
14631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14632 
 
14633 
  def __eq__(self, other):
14634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14635 
 
14636 
  def __ne__(self, other):
14637 
    return not (self == other)
6821 amar.kumar 14638 
 
6903 anupam.sin 14639 
class insureItem_args:
14640 
  """
14641 
  Attributes:
14642 
   - itemId
14643 
   - cartId
14644 
   - toInsure
9299 kshitij.so 14645 
   - insurerType
6903 anupam.sin 14646 
  """
14647 
 
14648 
  thrift_spec = (
14649 
    None, # 0
14650 
    (1, TType.I64, 'itemId', None, None, ), # 1
14651 
    (2, TType.I64, 'cartId', None, None, ), # 2
14652 
    (3, TType.BOOL, 'toInsure', None, None, ), # 3
9299 kshitij.so 14653 
    (4, TType.I32, 'insurerType', None, None, ), # 4
6903 anupam.sin 14654 
  )
14655 
 
9299 kshitij.so 14656 
  def __init__(self, itemId=None, cartId=None, toInsure=None, insurerType=None,):
6903 anupam.sin 14657 
    self.itemId = itemId
14658 
    self.cartId = cartId
14659 
    self.toInsure = toInsure
9299 kshitij.so 14660 
    self.insurerType = insurerType
6903 anupam.sin 14661 
 
14662 
  def read(self, iprot):
14663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14665 
      return
14666 
    iprot.readStructBegin()
14667 
    while True:
14668 
      (fname, ftype, fid) = iprot.readFieldBegin()
14669 
      if ftype == TType.STOP:
14670 
        break
14671 
      if fid == 1:
14672 
        if ftype == TType.I64:
14673 
          self.itemId = iprot.readI64();
14674 
        else:
14675 
          iprot.skip(ftype)
14676 
      elif fid == 2:
14677 
        if ftype == TType.I64:
14678 
          self.cartId = iprot.readI64();
14679 
        else:
14680 
          iprot.skip(ftype)
14681 
      elif fid == 3:
14682 
        if ftype == TType.BOOL:
14683 
          self.toInsure = iprot.readBool();
14684 
        else:
14685 
          iprot.skip(ftype)
9299 kshitij.so 14686 
      elif fid == 4:
14687 
        if ftype == TType.I32:
14688 
          self.insurerType = iprot.readI32();
14689 
        else:
14690 
          iprot.skip(ftype)
6903 anupam.sin 14691 
      else:
14692 
        iprot.skip(ftype)
14693 
      iprot.readFieldEnd()
14694 
    iprot.readStructEnd()
14695 
 
14696 
  def write(self, oprot):
14697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14699 
      return
14700 
    oprot.writeStructBegin('insureItem_args')
14701 
    if self.itemId is not None:
14702 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14703 
      oprot.writeI64(self.itemId)
14704 
      oprot.writeFieldEnd()
14705 
    if self.cartId is not None:
14706 
      oprot.writeFieldBegin('cartId', TType.I64, 2)
14707 
      oprot.writeI64(self.cartId)
14708 
      oprot.writeFieldEnd()
14709 
    if self.toInsure is not None:
14710 
      oprot.writeFieldBegin('toInsure', TType.BOOL, 3)
14711 
      oprot.writeBool(self.toInsure)
14712 
      oprot.writeFieldEnd()
9299 kshitij.so 14713 
    if self.insurerType is not None:
14714 
      oprot.writeFieldBegin('insurerType', TType.I32, 4)
14715 
      oprot.writeI32(self.insurerType)
14716 
      oprot.writeFieldEnd()
6903 anupam.sin 14717 
    oprot.writeFieldStop()
14718 
    oprot.writeStructEnd()
14719 
 
14720 
  def validate(self):
14721 
    return
14722 
 
14723 
 
14724 
  def __repr__(self):
14725 
    L = ['%s=%r' % (key, value)
14726 
      for key, value in self.__dict__.iteritems()]
14727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14728 
 
14729 
  def __eq__(self, other):
14730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14731 
 
14732 
  def __ne__(self, other):
14733 
    return not (self == other)
14734 
 
14735 
class insureItem_result:
14736 
  """
14737 
  Attributes:
14738 
   - success
14739 
  """
14740 
 
14741 
  thrift_spec = (
14742 
    (0, TType.BOOL, 'success', None, None, ), # 0
14743 
  )
14744 
 
14745 
  def __init__(self, success=None,):
14746 
    self.success = success
14747 
 
14748 
  def read(self, iprot):
14749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14751 
      return
14752 
    iprot.readStructBegin()
14753 
    while True:
14754 
      (fname, ftype, fid) = iprot.readFieldBegin()
14755 
      if ftype == TType.STOP:
14756 
        break
14757 
      if fid == 0:
14758 
        if ftype == TType.BOOL:
14759 
          self.success = iprot.readBool();
14760 
        else:
14761 
          iprot.skip(ftype)
14762 
      else:
14763 
        iprot.skip(ftype)
14764 
      iprot.readFieldEnd()
14765 
    iprot.readStructEnd()
14766 
 
14767 
  def write(self, oprot):
14768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14770 
      return
14771 
    oprot.writeStructBegin('insureItem_result')
14772 
    if self.success is not None:
14773 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14774 
      oprot.writeBool(self.success)
14775 
      oprot.writeFieldEnd()
14776 
    oprot.writeFieldStop()
14777 
    oprot.writeStructEnd()
14778 
 
14779 
  def validate(self):
14780 
    return
14781 
 
14782 
 
14783 
  def __repr__(self):
14784 
    L = ['%s=%r' % (key, value)
14785 
      for key, value in self.__dict__.iteritems()]
14786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14787 
 
14788 
  def __eq__(self, other):
14789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14790 
 
14791 
  def __ne__(self, other):
14792 
    return not (self == other)
14793 
 
14794 
class cancelInsurance_args:
14795 
  """
14796 
  Attributes:
14797 
   - cartId
14798 
  """
14799 
 
14800 
  thrift_spec = (
14801 
    None, # 0
14802 
    (1, TType.I64, 'cartId', None, None, ), # 1
14803 
  )
14804 
 
14805 
  def __init__(self, cartId=None,):
14806 
    self.cartId = cartId
14807 
 
14808 
  def read(self, iprot):
14809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14811 
      return
14812 
    iprot.readStructBegin()
14813 
    while True:
14814 
      (fname, ftype, fid) = iprot.readFieldBegin()
14815 
      if ftype == TType.STOP:
14816 
        break
14817 
      if fid == 1:
14818 
        if ftype == TType.I64:
14819 
          self.cartId = iprot.readI64();
14820 
        else:
14821 
          iprot.skip(ftype)
14822 
      else:
14823 
        iprot.skip(ftype)
14824 
      iprot.readFieldEnd()
14825 
    iprot.readStructEnd()
14826 
 
14827 
  def write(self, oprot):
14828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14830 
      return
14831 
    oprot.writeStructBegin('cancelInsurance_args')
14832 
    if self.cartId is not None:
14833 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
14834 
      oprot.writeI64(self.cartId)
14835 
      oprot.writeFieldEnd()
14836 
    oprot.writeFieldStop()
14837 
    oprot.writeStructEnd()
14838 
 
14839 
  def validate(self):
14840 
    return
14841 
 
14842 
 
14843 
  def __repr__(self):
14844 
    L = ['%s=%r' % (key, value)
14845 
      for key, value in self.__dict__.iteritems()]
14846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14847 
 
14848 
  def __eq__(self, other):
14849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14850 
 
14851 
  def __ne__(self, other):
14852 
    return not (self == other)
14853 
 
14854 
class cancelInsurance_result:
14855 
  """
14856 
  Attributes:
14857 
   - success
14858 
  """
14859 
 
14860 
  thrift_spec = (
14861 
    (0, TType.BOOL, 'success', None, None, ), # 0
14862 
  )
14863 
 
14864 
  def __init__(self, success=None,):
14865 
    self.success = success
14866 
 
14867 
  def read(self, iprot):
14868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14870 
      return
14871 
    iprot.readStructBegin()
14872 
    while True:
14873 
      (fname, ftype, fid) = iprot.readFieldBegin()
14874 
      if ftype == TType.STOP:
14875 
        break
14876 
      if fid == 0:
14877 
        if ftype == TType.BOOL:
14878 
          self.success = iprot.readBool();
14879 
        else:
14880 
          iprot.skip(ftype)
14881 
      else:
14882 
        iprot.skip(ftype)
14883 
      iprot.readFieldEnd()
14884 
    iprot.readStructEnd()
14885 
 
14886 
  def write(self, oprot):
14887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14889 
      return
14890 
    oprot.writeStructBegin('cancelInsurance_result')
14891 
    if self.success is not None:
14892 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14893 
      oprot.writeBool(self.success)
14894 
      oprot.writeFieldEnd()
14895 
    oprot.writeFieldStop()
14896 
    oprot.writeStructEnd()
14897 
 
14898 
  def validate(self):
14899 
    return
14900 
 
14901 
 
14902 
  def __repr__(self):
14903 
    L = ['%s=%r' % (key, value)
14904 
      for key, value in self.__dict__.iteritems()]
14905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14906 
 
14907 
  def __eq__(self, other):
14908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14909 
 
14910 
  def __ne__(self, other):
14911 
    return not (self == other)
14912 
 
14913 
class storeInsuranceSpecificDetails_args:
14914 
  """
14915 
  Attributes:
14916 
   - addressId
14917 
   - dob
14918 
   - guardianName
14919 
  """
14920 
 
14921 
  thrift_spec = (
14922 
    None, # 0
14923 
    (1, TType.I64, 'addressId', None, None, ), # 1
14924 
    (2, TType.STRING, 'dob', None, None, ), # 2
14925 
    (3, TType.STRING, 'guardianName', None, None, ), # 3
14926 
  )
14927 
 
14928 
  def __init__(self, addressId=None, dob=None, guardianName=None,):
14929 
    self.addressId = addressId
14930 
    self.dob = dob
14931 
    self.guardianName = guardianName
14932 
 
14933 
  def read(self, iprot):
14934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14936 
      return
14937 
    iprot.readStructBegin()
14938 
    while True:
14939 
      (fname, ftype, fid) = iprot.readFieldBegin()
14940 
      if ftype == TType.STOP:
14941 
        break
14942 
      if fid == 1:
14943 
        if ftype == TType.I64:
14944 
          self.addressId = iprot.readI64();
14945 
        else:
14946 
          iprot.skip(ftype)
14947 
      elif fid == 2:
14948 
        if ftype == TType.STRING:
14949 
          self.dob = iprot.readString();
14950 
        else:
14951 
          iprot.skip(ftype)
14952 
      elif fid == 3:
14953 
        if ftype == TType.STRING:
14954 
          self.guardianName = iprot.readString();
14955 
        else:
14956 
          iprot.skip(ftype)
14957 
      else:
14958 
        iprot.skip(ftype)
14959 
      iprot.readFieldEnd()
14960 
    iprot.readStructEnd()
14961 
 
14962 
  def write(self, oprot):
14963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14965 
      return
14966 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_args')
14967 
    if self.addressId is not None:
14968 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
14969 
      oprot.writeI64(self.addressId)
14970 
      oprot.writeFieldEnd()
14971 
    if self.dob is not None:
14972 
      oprot.writeFieldBegin('dob', TType.STRING, 2)
14973 
      oprot.writeString(self.dob)
14974 
      oprot.writeFieldEnd()
14975 
    if self.guardianName is not None:
14976 
      oprot.writeFieldBegin('guardianName', TType.STRING, 3)
14977 
      oprot.writeString(self.guardianName)
14978 
      oprot.writeFieldEnd()
14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
14997 
class storeInsuranceSpecificDetails_result:
14998 
  """
14999 
  Attributes:
15000 
   - success
15001 
  """
15002 
 
15003 
  thrift_spec = (
15004 
    (0, TType.BOOL, 'success', None, None, ), # 0
15005 
  )
15006 
 
15007 
  def __init__(self, success=None,):
15008 
    self.success = success
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 0:
15020 
        if ftype == TType.BOOL:
15021 
          self.success = iprot.readBool();
15022 
        else:
15023 
          iprot.skip(ftype)
15024 
      else:
15025 
        iprot.skip(ftype)
15026 
      iprot.readFieldEnd()
15027 
    iprot.readStructEnd()
15028 
 
15029 
  def write(self, oprot):
15030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15032 
      return
15033 
    oprot.writeStructBegin('storeInsuranceSpecificDetails_result')
15034 
    if self.success is not None:
15035 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15036 
      oprot.writeBool(self.success)
15037 
      oprot.writeFieldEnd()
15038 
    oprot.writeFieldStop()
15039 
    oprot.writeStructEnd()
15040 
 
15041 
  def validate(self):
15042 
    return
15043 
 
15044 
 
15045 
  def __repr__(self):
15046 
    L = ['%s=%r' % (key, value)
15047 
      for key, value in self.__dict__.iteritems()]
15048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15049 
 
15050 
  def __eq__(self, other):
15051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15052 
 
15053 
  def __ne__(self, other):
15054 
    return not (self == other)
15055 
 
15056 
class isInsuranceDetailPresent_args:
15057 
  """
15058 
  Attributes:
15059 
   - addressId
15060 
  """
15061 
 
15062 
  thrift_spec = (
15063 
    None, # 0
15064 
    (1, TType.I64, 'addressId', None, None, ), # 1
15065 
  )
15066 
 
15067 
  def __init__(self, addressId=None,):
15068 
    self.addressId = addressId
15069 
 
15070 
  def read(self, iprot):
15071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15073 
      return
15074 
    iprot.readStructBegin()
15075 
    while True:
15076 
      (fname, ftype, fid) = iprot.readFieldBegin()
15077 
      if ftype == TType.STOP:
15078 
        break
15079 
      if fid == 1:
15080 
        if ftype == TType.I64:
15081 
          self.addressId = iprot.readI64();
15082 
        else:
15083 
          iprot.skip(ftype)
15084 
      else:
15085 
        iprot.skip(ftype)
15086 
      iprot.readFieldEnd()
15087 
    iprot.readStructEnd()
15088 
 
15089 
  def write(self, oprot):
15090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15092 
      return
15093 
    oprot.writeStructBegin('isInsuranceDetailPresent_args')
15094 
    if self.addressId is not None:
15095 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
15096 
      oprot.writeI64(self.addressId)
15097 
      oprot.writeFieldEnd()
15098 
    oprot.writeFieldStop()
15099 
    oprot.writeStructEnd()
15100 
 
15101 
  def validate(self):
15102 
    return
15103 
 
15104 
 
15105 
  def __repr__(self):
15106 
    L = ['%s=%r' % (key, value)
15107 
      for key, value in self.__dict__.iteritems()]
15108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15109 
 
15110 
  def __eq__(self, other):
15111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15112 
 
15113 
  def __ne__(self, other):
15114 
    return not (self == other)
15115 
 
15116 
class isInsuranceDetailPresent_result:
15117 
  """
15118 
  Attributes:
15119 
   - success
15120 
  """
15121 
 
15122 
  thrift_spec = (
15123 
    (0, TType.BOOL, 'success', None, None, ), # 0
15124 
  )
15125 
 
15126 
  def __init__(self, success=None,):
15127 
    self.success = success
15128 
 
15129 
  def read(self, iprot):
15130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15132 
      return
15133 
    iprot.readStructBegin()
15134 
    while True:
15135 
      (fname, ftype, fid) = iprot.readFieldBegin()
15136 
      if ftype == TType.STOP:
15137 
        break
15138 
      if fid == 0:
15139 
        if ftype == TType.BOOL:
15140 
          self.success = iprot.readBool();
15141 
        else:
15142 
          iprot.skip(ftype)
15143 
      else:
15144 
        iprot.skip(ftype)
15145 
      iprot.readFieldEnd()
15146 
    iprot.readStructEnd()
15147 
 
15148 
  def write(self, oprot):
15149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15151 
      return
15152 
    oprot.writeStructBegin('isInsuranceDetailPresent_result')
15153 
    if self.success is not None:
15154 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15155 
      oprot.writeBool(self.success)
15156 
      oprot.writeFieldEnd()
15157 
    oprot.writeFieldStop()
15158 
    oprot.writeStructEnd()
15159 
 
15160 
  def validate(self):
15161 
    return
15162 
 
15163 
 
15164 
  def __repr__(self):
15165 
    L = ['%s=%r' % (key, value)
15166 
      for key, value in self.__dict__.iteritems()]
15167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15168 
 
15169 
  def __eq__(self, other):
15170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15171 
 
15172 
  def __ne__(self, other):
15173 
    return not (self == other)
15174 
 
9791 rajveer 15175 
class getProductsAddedToCart_args:
6821 amar.kumar 15176 
  """
15177 
  Attributes:
15178 
   - startDate
15179 
   - endDate
15180 
  """
15181 
 
15182 
  thrift_spec = (
15183 
    None, # 0
9791 rajveer 15184 
    (1, TType.I64, 'startDate', None, None, ), # 1
15185 
    (2, TType.I64, 'endDate', None, None, ), # 2
6821 amar.kumar 15186 
  )
15187 
 
9791 rajveer 15188 
  def __init__(self, startDate=None, endDate=None,):
6821 amar.kumar 15189 
    self.startDate = startDate
15190 
    self.endDate = endDate
15191 
 
15192 
  def read(self, iprot):
15193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15195 
      return
15196 
    iprot.readStructBegin()
15197 
    while True:
15198 
      (fname, ftype, fid) = iprot.readFieldBegin()
15199 
      if ftype == TType.STOP:
15200 
        break
15201 
      if fid == 1:
15202 
        if ftype == TType.I64:
9791 rajveer 15203 
          self.startDate = iprot.readI64();
6821 amar.kumar 15204 
        else:
15205 
          iprot.skip(ftype)
15206 
      elif fid == 2:
15207 
        if ftype == TType.I64:
15208 
          self.endDate = iprot.readI64();
15209 
        else:
15210 
          iprot.skip(ftype)
15211 
      else:
15212 
        iprot.skip(ftype)
15213 
      iprot.readFieldEnd()
15214 
    iprot.readStructEnd()
15215 
 
15216 
  def write(self, oprot):
15217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15219 
      return
9791 rajveer 15220 
    oprot.writeStructBegin('getProductsAddedToCart_args')
6821 amar.kumar 15221 
    if self.startDate is not None:
9791 rajveer 15222 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
6821 amar.kumar 15223 
      oprot.writeI64(self.startDate)
15224 
      oprot.writeFieldEnd()
15225 
    if self.endDate is not None:
9791 rajveer 15226 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
6821 amar.kumar 15227 
      oprot.writeI64(self.endDate)
15228 
      oprot.writeFieldEnd()
15229 
    oprot.writeFieldStop()
15230 
    oprot.writeStructEnd()
15231 
 
15232 
  def validate(self):
15233 
    return
15234 
 
15235 
 
15236 
  def __repr__(self):
15237 
    L = ['%s=%r' % (key, value)
15238 
      for key, value in self.__dict__.iteritems()]
15239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15240 
 
15241 
  def __eq__(self, other):
15242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15243 
 
15244 
  def __ne__(self, other):
15245 
    return not (self == other)
15246 
 
9791 rajveer 15247 
class getProductsAddedToCart_result:
6821 amar.kumar 15248 
  """
15249 
  Attributes:
15250 
   - success
15251 
  """
15252 
 
15253 
  thrift_spec = (
9791 rajveer 15254 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6821 amar.kumar 15255 
  )
15256 
 
15257 
  def __init__(self, success=None,):
15258 
    self.success = success
15259 
 
15260 
  def read(self, iprot):
15261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15263 
      return
15264 
    iprot.readStructBegin()
15265 
    while True:
15266 
      (fname, ftype, fid) = iprot.readFieldBegin()
15267 
      if ftype == TType.STOP:
15268 
        break
15269 
      if fid == 0:
9791 rajveer 15270 
        if ftype == TType.LIST:
15271 
          self.success = []
11980 amit.gupta 15272 
          (_etype221, _size218) = iprot.readListBegin()
15273 
          for _i222 in xrange(_size218):
15274 
            _elem223 = iprot.readI64();
15275 
            self.success.append(_elem223)
9791 rajveer 15276 
          iprot.readListEnd()
6821 amar.kumar 15277 
        else:
15278 
          iprot.skip(ftype)
15279 
      else:
15280 
        iprot.skip(ftype)
15281 
      iprot.readFieldEnd()
15282 
    iprot.readStructEnd()
15283 
 
15284 
  def write(self, oprot):
15285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15287 
      return
9791 rajveer 15288 
    oprot.writeStructBegin('getProductsAddedToCart_result')
6821 amar.kumar 15289 
    if self.success is not None:
9791 rajveer 15290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15291 
      oprot.writeListBegin(TType.I64, len(self.success))
11980 amit.gupta 15292 
      for iter224 in self.success:
15293 
        oprot.writeI64(iter224)
9791 rajveer 15294 
      oprot.writeListEnd()
6821 amar.kumar 15295 
      oprot.writeFieldEnd()
15296 
    oprot.writeFieldStop()
15297 
    oprot.writeStructEnd()
15298 
 
15299 
  def validate(self):
15300 
    return
15301 
 
15302 
 
15303 
  def __repr__(self):
15304 
    L = ['%s=%r' % (key, value)
15305 
      for key, value in self.__dict__.iteritems()]
15306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15307 
 
15308 
  def __eq__(self, other):
15309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15310 
 
15311 
  def __ne__(self, other):
15312 
    return not (self == other)
11592 amit.gupta 15313 
 
15314 
class validateCartPlus_args:
15315 
  """
15316 
  Attributes:
15317 
   - cartId
15318 
   - sourceId
11980 amit.gupta 15319 
   - dealerCoupon
11592 amit.gupta 15320 
  """
15321 
 
15322 
  thrift_spec = (
15323 
    None, # 0
15324 
    (1, TType.I64, 'cartId', None, None, ), # 1
15325 
    (2, TType.I64, 'sourceId', None, None, ), # 2
11980 amit.gupta 15326 
    (3, TType.STRING, 'dealerCoupon', None, None, ), # 3
11592 amit.gupta 15327 
  )
15328 
 
11980 amit.gupta 15329 
  def __init__(self, cartId=None, sourceId=None, dealerCoupon=None,):
11592 amit.gupta 15330 
    self.cartId = cartId
15331 
    self.sourceId = sourceId
11980 amit.gupta 15332 
    self.dealerCoupon = dealerCoupon
11592 amit.gupta 15333 
 
15334 
  def read(self, iprot):
15335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15337 
      return
15338 
    iprot.readStructBegin()
15339 
    while True:
15340 
      (fname, ftype, fid) = iprot.readFieldBegin()
15341 
      if ftype == TType.STOP:
15342 
        break
15343 
      if fid == 1:
15344 
        if ftype == TType.I64:
15345 
          self.cartId = iprot.readI64();
15346 
        else:
15347 
          iprot.skip(ftype)
15348 
      elif fid == 2:
15349 
        if ftype == TType.I64:
15350 
          self.sourceId = iprot.readI64();
15351 
        else:
15352 
          iprot.skip(ftype)
11980 amit.gupta 15353 
      elif fid == 3:
15354 
        if ftype == TType.STRING:
15355 
          self.dealerCoupon = iprot.readString();
15356 
        else:
15357 
          iprot.skip(ftype)
11592 amit.gupta 15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('validateCartPlus_args')
15368 
    if self.cartId is not None:
15369 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
15370 
      oprot.writeI64(self.cartId)
15371 
      oprot.writeFieldEnd()
15372 
    if self.sourceId is not None:
15373 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15374 
      oprot.writeI64(self.sourceId)
15375 
      oprot.writeFieldEnd()
11980 amit.gupta 15376 
    if self.dealerCoupon is not None:
15377 
      oprot.writeFieldBegin('dealerCoupon', TType.STRING, 3)
15378 
      oprot.writeString(self.dealerCoupon)
15379 
      oprot.writeFieldEnd()
11592 amit.gupta 15380 
    oprot.writeFieldStop()
15381 
    oprot.writeStructEnd()
15382 
 
15383 
  def validate(self):
15384 
    return
15385 
 
15386 
 
15387 
  def __repr__(self):
15388 
    L = ['%s=%r' % (key, value)
15389 
      for key, value in self.__dict__.iteritems()]
15390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15391 
 
15392 
  def __eq__(self, other):
15393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15394 
 
15395 
  def __ne__(self, other):
15396 
    return not (self == other)
15397 
 
15398 
class validateCartPlus_result:
15399 
  """
15400 
  Attributes:
15401 
   - success
15402 
   - scex
15403 
  """
15404 
 
15405 
  thrift_spec = (
15406 
    (0, TType.STRUCT, 'success', (CartPlus, CartPlus.thrift_spec), None, ), # 0
15407 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
15408 
  )
15409 
 
15410 
  def __init__(self, success=None, scex=None,):
15411 
    self.success = success
15412 
    self.scex = scex
15413 
 
15414 
  def read(self, iprot):
15415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15417 
      return
15418 
    iprot.readStructBegin()
15419 
    while True:
15420 
      (fname, ftype, fid) = iprot.readFieldBegin()
15421 
      if ftype == TType.STOP:
15422 
        break
15423 
      if fid == 0:
15424 
        if ftype == TType.STRUCT:
15425 
          self.success = CartPlus()
15426 
          self.success.read(iprot)
15427 
        else:
15428 
          iprot.skip(ftype)
15429 
      elif fid == 1:
15430 
        if ftype == TType.STRUCT:
15431 
          self.scex = ShoppingCartException()
15432 
          self.scex.read(iprot)
15433 
        else:
15434 
          iprot.skip(ftype)
15435 
      else:
15436 
        iprot.skip(ftype)
15437 
      iprot.readFieldEnd()
15438 
    iprot.readStructEnd()
15439 
 
15440 
  def write(self, oprot):
15441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15443 
      return
15444 
    oprot.writeStructBegin('validateCartPlus_result')
15445 
    if self.success is not None:
15446 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15447 
      self.success.write(oprot)
15448 
      oprot.writeFieldEnd()
15449 
    if self.scex is not None:
15450 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
15451 
      self.scex.write(oprot)
15452 
      oprot.writeFieldEnd()
15453 
    oprot.writeFieldStop()
15454 
    oprot.writeStructEnd()
15455 
 
15456 
  def validate(self):
15457 
    return
15458 
 
15459 
 
15460 
  def __repr__(self):
15461 
    L = ['%s=%r' % (key, value)
15462 
      for key, value in self.__dict__.iteritems()]
15463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15464 
 
15465 
  def __eq__(self, other):
15466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15467 
 
15468 
  def __ne__(self, other):
15469 
    return not (self == other)
11679 vikram.rag 15470 
 
15471 
class isPrivateDealUser_args:
15472 
  """
15473 
  Attributes:
15474 
   - userId
15475 
  """
15476 
 
15477 
  thrift_spec = (
15478 
    None, # 0
15479 
    (1, TType.I64, 'userId', None, None, ), # 1
15480 
  )
15481 
 
15482 
  def __init__(self, userId=None,):
15483 
    self.userId = userId
15484 
 
15485 
  def read(self, iprot):
15486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15488 
      return
15489 
    iprot.readStructBegin()
15490 
    while True:
15491 
      (fname, ftype, fid) = iprot.readFieldBegin()
15492 
      if ftype == TType.STOP:
15493 
        break
15494 
      if fid == 1:
15495 
        if ftype == TType.I64:
15496 
          self.userId = iprot.readI64();
15497 
        else:
15498 
          iprot.skip(ftype)
15499 
      else:
15500 
        iprot.skip(ftype)
15501 
      iprot.readFieldEnd()
15502 
    iprot.readStructEnd()
15503 
 
15504 
  def write(self, oprot):
15505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15507 
      return
15508 
    oprot.writeStructBegin('isPrivateDealUser_args')
15509 
    if self.userId is not None:
15510 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15511 
      oprot.writeI64(self.userId)
15512 
      oprot.writeFieldEnd()
15513 
    oprot.writeFieldStop()
15514 
    oprot.writeStructEnd()
15515 
 
15516 
  def validate(self):
15517 
    return
15518 
 
15519 
 
15520 
  def __repr__(self):
15521 
    L = ['%s=%r' % (key, value)
15522 
      for key, value in self.__dict__.iteritems()]
15523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15524 
 
15525 
  def __eq__(self, other):
15526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15527 
 
15528 
  def __ne__(self, other):
15529 
    return not (self == other)
15530 
 
15531 
class isPrivateDealUser_result:
15532 
  """
15533 
  Attributes:
15534 
   - success
15535 
  """
15536 
 
15537 
  thrift_spec = (
15538 
    (0, TType.BOOL, 'success', None, None, ), # 0
15539 
  )
15540 
 
15541 
  def __init__(self, success=None,):
15542 
    self.success = success
15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
15553 
      if fid == 0:
15554 
        if ftype == TType.BOOL:
15555 
          self.success = iprot.readBool();
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      else:
15559 
        iprot.skip(ftype)
15560 
      iprot.readFieldEnd()
15561 
    iprot.readStructEnd()
15562 
 
15563 
  def write(self, oprot):
15564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15566 
      return
15567 
    oprot.writeStructBegin('isPrivateDealUser_result')
15568 
    if self.success is not None:
15569 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15570 
      oprot.writeBool(self.success)
15571 
      oprot.writeFieldEnd()
15572 
    oprot.writeFieldStop()
15573 
    oprot.writeStructEnd()
15574 
 
15575 
  def validate(self):
15576 
    return
15577 
 
15578 
 
15579 
  def __repr__(self):
15580 
    L = ['%s=%r' % (key, value)
15581 
      for key, value in self.__dict__.iteritems()]
15582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15583 
 
15584 
  def __eq__(self, other):
15585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15586 
 
15587 
  def __ne__(self, other):
15588 
    return not (self == other)
11890 kshitij.so 15589 
 
15590 
class addPrivateDealUser_args:
15591 
  """
15592 
  Attributes:
15593 
   - userId
15594 
  """
15595 
 
15596 
  thrift_spec = (
15597 
    None, # 0
15598 
    (1, TType.I64, 'userId', None, None, ), # 1
15599 
  )
15600 
 
15601 
  def __init__(self, userId=None,):
15602 
    self.userId = userId
15603 
 
15604 
  def read(self, iprot):
15605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15607 
      return
15608 
    iprot.readStructBegin()
15609 
    while True:
15610 
      (fname, ftype, fid) = iprot.readFieldBegin()
15611 
      if ftype == TType.STOP:
15612 
        break
15613 
      if fid == 1:
15614 
        if ftype == TType.I64:
15615 
          self.userId = iprot.readI64();
15616 
        else:
15617 
          iprot.skip(ftype)
15618 
      else:
15619 
        iprot.skip(ftype)
15620 
      iprot.readFieldEnd()
15621 
    iprot.readStructEnd()
15622 
 
15623 
  def write(self, oprot):
15624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15626 
      return
15627 
    oprot.writeStructBegin('addPrivateDealUser_args')
15628 
    if self.userId is not None:
15629 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15630 
      oprot.writeI64(self.userId)
15631 
      oprot.writeFieldEnd()
15632 
    oprot.writeFieldStop()
15633 
    oprot.writeStructEnd()
15634 
 
15635 
  def validate(self):
15636 
    return
15637 
 
15638 
 
15639 
  def __repr__(self):
15640 
    L = ['%s=%r' % (key, value)
15641 
      for key, value in self.__dict__.iteritems()]
15642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15643 
 
15644 
  def __eq__(self, other):
15645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15646 
 
15647 
  def __ne__(self, other):
15648 
    return not (self == other)
15649 
 
15650 
class addPrivateDealUser_result:
15651 
  """
15652 
  Attributes:
15653 
   - success
15654 
  """
15655 
 
15656 
  thrift_spec = (
15657 
    (0, TType.BOOL, 'success', None, None, ), # 0
15658 
  )
15659 
 
15660 
  def __init__(self, success=None,):
15661 
    self.success = success
15662 
 
15663 
  def read(self, iprot):
15664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15666 
      return
15667 
    iprot.readStructBegin()
15668 
    while True:
15669 
      (fname, ftype, fid) = iprot.readFieldBegin()
15670 
      if ftype == TType.STOP:
15671 
        break
15672 
      if fid == 0:
15673 
        if ftype == TType.BOOL:
15674 
          self.success = iprot.readBool();
15675 
        else:
15676 
          iprot.skip(ftype)
15677 
      else:
15678 
        iprot.skip(ftype)
15679 
      iprot.readFieldEnd()
15680 
    iprot.readStructEnd()
15681 
 
15682 
  def write(self, oprot):
15683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15685 
      return
15686 
    oprot.writeStructBegin('addPrivateDealUser_result')
15687 
    if self.success is not None:
15688 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15689 
      oprot.writeBool(self.success)
15690 
      oprot.writeFieldEnd()
15691 
    oprot.writeFieldStop()
15692 
    oprot.writeStructEnd()
15693 
 
15694 
  def validate(self):
15695 
    return
15696 
 
15697 
 
15698 
  def __repr__(self):
15699 
    L = ['%s=%r' % (key, value)
15700 
      for key, value in self.__dict__.iteritems()]
15701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15702 
 
15703 
  def __eq__(self, other):
15704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15705 
 
15706 
  def __ne__(self, other):
15707 
    return not (self == other)
15708 
 
15709 
class changePrivateDealUserStatus_args:
15710 
  """
15711 
  Attributes:
15712 
   - userId
15713 
   - isActive
15714 
  """
15715 
 
15716 
  thrift_spec = (
15717 
    None, # 0
15718 
    (1, TType.I64, 'userId', None, None, ), # 1
15719 
    (2, TType.BOOL, 'isActive', None, None, ), # 2
15720 
  )
15721 
 
15722 
  def __init__(self, userId=None, isActive=None,):
15723 
    self.userId = userId
15724 
    self.isActive = isActive
15725 
 
15726 
  def read(self, iprot):
15727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15729 
      return
15730 
    iprot.readStructBegin()
15731 
    while True:
15732 
      (fname, ftype, fid) = iprot.readFieldBegin()
15733 
      if ftype == TType.STOP:
15734 
        break
15735 
      if fid == 1:
15736 
        if ftype == TType.I64:
15737 
          self.userId = iprot.readI64();
15738 
        else:
15739 
          iprot.skip(ftype)
15740 
      elif fid == 2:
15741 
        if ftype == TType.BOOL:
15742 
          self.isActive = iprot.readBool();
15743 
        else:
15744 
          iprot.skip(ftype)
15745 
      else:
15746 
        iprot.skip(ftype)
15747 
      iprot.readFieldEnd()
15748 
    iprot.readStructEnd()
15749 
 
15750 
  def write(self, oprot):
15751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15753 
      return
15754 
    oprot.writeStructBegin('changePrivateDealUserStatus_args')
15755 
    if self.userId is not None:
15756 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15757 
      oprot.writeI64(self.userId)
15758 
      oprot.writeFieldEnd()
15759 
    if self.isActive is not None:
15760 
      oprot.writeFieldBegin('isActive', TType.BOOL, 2)
15761 
      oprot.writeBool(self.isActive)
15762 
      oprot.writeFieldEnd()
15763 
    oprot.writeFieldStop()
15764 
    oprot.writeStructEnd()
15765 
 
15766 
  def validate(self):
15767 
    return
15768 
 
15769 
 
15770 
  def __repr__(self):
15771 
    L = ['%s=%r' % (key, value)
15772 
      for key, value in self.__dict__.iteritems()]
15773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15774 
 
15775 
  def __eq__(self, other):
15776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15777 
 
15778 
  def __ne__(self, other):
15779 
    return not (self == other)
15780 
 
15781 
class changePrivateDealUserStatus_result:
15782 
  """
15783 
  Attributes:
15784 
   - success
15785 
  """
15786 
 
15787 
  thrift_spec = (
15788 
    (0, TType.BOOL, 'success', None, None, ), # 0
15789 
  )
15790 
 
15791 
  def __init__(self, success=None,):
15792 
    self.success = success
15793 
 
15794 
  def read(self, iprot):
15795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15797 
      return
15798 
    iprot.readStructBegin()
15799 
    while True:
15800 
      (fname, ftype, fid) = iprot.readFieldBegin()
15801 
      if ftype == TType.STOP:
15802 
        break
15803 
      if fid == 0:
15804 
        if ftype == TType.BOOL:
15805 
          self.success = iprot.readBool();
15806 
        else:
15807 
          iprot.skip(ftype)
15808 
      else:
15809 
        iprot.skip(ftype)
15810 
      iprot.readFieldEnd()
15811 
    iprot.readStructEnd()
15812 
 
15813 
  def write(self, oprot):
15814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15816 
      return
15817 
    oprot.writeStructBegin('changePrivateDealUserStatus_result')
15818 
    if self.success is not None:
15819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15820 
      oprot.writeBool(self.success)
15821 
      oprot.writeFieldEnd()
15822 
    oprot.writeFieldStop()
15823 
    oprot.writeStructEnd()
15824 
 
15825 
  def validate(self):
15826 
    return
15827 
 
15828 
 
15829 
  def __repr__(self):
15830 
    L = ['%s=%r' % (key, value)
15831 
      for key, value in self.__dict__.iteritems()]
15832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15833 
 
15834 
  def __eq__(self, other):
15835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15836 
 
15837 
  def __ne__(self, other):
15838 
    return not (self == other)
15839 
 
15840 
class getPrivateDealUser_args:
15841 
  """
15842 
  Attributes:
15843 
   - userId
15844 
  """
15845 
 
15846 
  thrift_spec = (
15847 
    None, # 0
15848 
    (1, TType.I64, 'userId', None, None, ), # 1
15849 
  )
15850 
 
15851 
  def __init__(self, userId=None,):
15852 
    self.userId = userId
15853 
 
15854 
  def read(self, iprot):
15855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15857 
      return
15858 
    iprot.readStructBegin()
15859 
    while True:
15860 
      (fname, ftype, fid) = iprot.readFieldBegin()
15861 
      if ftype == TType.STOP:
15862 
        break
15863 
      if fid == 1:
15864 
        if ftype == TType.I64:
15865 
          self.userId = iprot.readI64();
15866 
        else:
15867 
          iprot.skip(ftype)
15868 
      else:
15869 
        iprot.skip(ftype)
15870 
      iprot.readFieldEnd()
15871 
    iprot.readStructEnd()
15872 
 
15873 
  def write(self, oprot):
15874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15876 
      return
15877 
    oprot.writeStructBegin('getPrivateDealUser_args')
15878 
    if self.userId is not None:
15879 
      oprot.writeFieldBegin('userId', TType.I64, 1)
15880 
      oprot.writeI64(self.userId)
15881 
      oprot.writeFieldEnd()
15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
15899 
 
15900 
class getPrivateDealUser_result:
15901 
  """
15902 
  Attributes:
15903 
   - success
15904 
  """
15905 
 
15906 
  thrift_spec = (
15907 
    (0, TType.STRUCT, 'success', (PrivateDealUser, PrivateDealUser.thrift_spec), None, ), # 0
15908 
  )
15909 
 
15910 
  def __init__(self, success=None,):
15911 
    self.success = success
15912 
 
15913 
  def read(self, iprot):
15914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15916 
      return
15917 
    iprot.readStructBegin()
15918 
    while True:
15919 
      (fname, ftype, fid) = iprot.readFieldBegin()
15920 
      if ftype == TType.STOP:
15921 
        break
15922 
      if fid == 0:
15923 
        if ftype == TType.STRUCT:
15924 
          self.success = PrivateDealUser()
15925 
          self.success.read(iprot)
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
15937 
    oprot.writeStructBegin('getPrivateDealUser_result')
15938 
    if self.success is not None:
15939 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15940 
      self.success.write(oprot)
15941 
      oprot.writeFieldEnd()
15942 
    oprot.writeFieldStop()
15943 
    oprot.writeStructEnd()
15944 
 
15945 
  def validate(self):
15946 
    return
15947 
 
15948 
 
15949 
  def __repr__(self):
15950 
    L = ['%s=%r' % (key, value)
15951 
      for key, value in self.__dict__.iteritems()]
15952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15953 
 
15954 
  def __eq__(self, other):
15955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15956 
 
15957 
  def __ne__(self, other):
15958 
    return not (self == other)
12696 amit.gupta 15959 
 
15960 
class registerCounter_args:
15961 
  """
15962 
  Attributes:
15963 
   - counter
15964 
   - userId
15965 
  """
15966 
 
15967 
  thrift_spec = (
15968 
    None, # 0
15969 
    (1, TType.STRUCT, 'counter', (Counter, Counter.thrift_spec), None, ), # 1
15970 
    (2, TType.I64, 'userId', None, None, ), # 2
15971 
  )
15972 
 
15973 
  def __init__(self, counter=None, userId=None,):
15974 
    self.counter = counter
15975 
    self.userId = userId
15976 
 
15977 
  def read(self, iprot):
15978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15980 
      return
15981 
    iprot.readStructBegin()
15982 
    while True:
15983 
      (fname, ftype, fid) = iprot.readFieldBegin()
15984 
      if ftype == TType.STOP:
15985 
        break
15986 
      if fid == 1:
15987 
        if ftype == TType.STRUCT:
15988 
          self.counter = Counter()
15989 
          self.counter.read(iprot)
15990 
        else:
15991 
          iprot.skip(ftype)
15992 
      elif fid == 2:
15993 
        if ftype == TType.I64:
15994 
          self.userId = iprot.readI64();
15995 
        else:
15996 
          iprot.skip(ftype)
15997 
      else:
15998 
        iprot.skip(ftype)
15999 
      iprot.readFieldEnd()
16000 
    iprot.readStructEnd()
16001 
 
16002 
  def write(self, oprot):
16003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16005 
      return
16006 
    oprot.writeStructBegin('registerCounter_args')
16007 
    if self.counter is not None:
16008 
      oprot.writeFieldBegin('counter', TType.STRUCT, 1)
16009 
      self.counter.write(oprot)
16010 
      oprot.writeFieldEnd()
16011 
    if self.userId is not None:
16012 
      oprot.writeFieldBegin('userId', TType.I64, 2)
16013 
      oprot.writeI64(self.userId)
16014 
      oprot.writeFieldEnd()
16015 
    oprot.writeFieldStop()
16016 
    oprot.writeStructEnd()
16017 
 
16018 
  def validate(self):
16019 
    return
16020 
 
16021 
 
16022 
  def __repr__(self):
16023 
    L = ['%s=%r' % (key, value)
16024 
      for key, value in self.__dict__.iteritems()]
16025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16026 
 
16027 
  def __eq__(self, other):
16028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16029 
 
16030 
  def __ne__(self, other):
16031 
    return not (self == other)
16032 
 
16033 
class registerCounter_result:
16034 
  """
16035 
  Attributes:
16036 
   - success
16037 
  """
16038 
 
16039 
  thrift_spec = (
16040 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
16041 
  )
16042 
 
16043 
  def __init__(self, success=None,):
16044 
    self.success = success
16045 
 
16046 
  def read(self, iprot):
16047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16049 
      return
16050 
    iprot.readStructBegin()
16051 
    while True:
16052 
      (fname, ftype, fid) = iprot.readFieldBegin()
16053 
      if ftype == TType.STOP:
16054 
        break
16055 
      if fid == 0:
16056 
        if ftype == TType.MAP:
16057 
          self.success = {}
16058 
          (_ktype226, _vtype227, _size225 ) = iprot.readMapBegin()
16059 
          for _i229 in xrange(_size225):
16060 
            _key230 = iprot.readString();
16061 
            _val231 = iprot.readString();
16062 
            self.success[_key230] = _val231
16063 
          iprot.readMapEnd()
16064 
        else:
16065 
          iprot.skip(ftype)
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('registerCounter_result')
16076 
    if self.success is not None:
16077 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16078 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
16079 
      for kiter232,viter233 in self.success.items():
16080 
        oprot.writeString(kiter232)
16081 
        oprot.writeString(viter233)
16082 
      oprot.writeMapEnd()
16083 
      oprot.writeFieldEnd()
16084 
    oprot.writeFieldStop()
16085 
    oprot.writeStructEnd()
16086 
 
16087 
  def validate(self):
16088 
    return
16089 
 
16090 
 
16091 
  def __repr__(self):
16092 
    L = ['%s=%r' % (key, value)
16093 
      for key, value in self.__dict__.iteritems()]
16094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16095 
 
16096 
  def __eq__(self, other):
16097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16098 
 
16099 
  def __ne__(self, other):
16100 
    return not (self == other)
12722 amit.gupta 16101 
 
16102 
class searchCounter_args:
16103 
  """
16104 
  Attributes:
16105 
   - type1
16106 
   - searchString
16107 
  """
16108 
 
16109 
  thrift_spec = (
16110 
    None, # 0
16111 
    (1, TType.STRING, 'type1', None, None, ), # 1
16112 
    (2, TType.STRING, 'searchString', None, None, ), # 2
16113 
  )
16114 
 
16115 
  def __init__(self, type1=None, searchString=None,):
16116 
    self.type1 = type1
16117 
    self.searchString = searchString
16118 
 
16119 
  def read(self, iprot):
16120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16122 
      return
16123 
    iprot.readStructBegin()
16124 
    while True:
16125 
      (fname, ftype, fid) = iprot.readFieldBegin()
16126 
      if ftype == TType.STOP:
16127 
        break
16128 
      if fid == 1:
16129 
        if ftype == TType.STRING:
16130 
          self.type1 = iprot.readString();
16131 
        else:
16132 
          iprot.skip(ftype)
16133 
      elif fid == 2:
16134 
        if ftype == TType.STRING:
16135 
          self.searchString = iprot.readString();
16136 
        else:
16137 
          iprot.skip(ftype)
16138 
      else:
16139 
        iprot.skip(ftype)
16140 
      iprot.readFieldEnd()
16141 
    iprot.readStructEnd()
16142 
 
16143 
  def write(self, oprot):
16144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16146 
      return
16147 
    oprot.writeStructBegin('searchCounter_args')
16148 
    if self.type1 is not None:
16149 
      oprot.writeFieldBegin('type1', TType.STRING, 1)
16150 
      oprot.writeString(self.type1)
16151 
      oprot.writeFieldEnd()
16152 
    if self.searchString is not None:
16153 
      oprot.writeFieldBegin('searchString', TType.STRING, 2)
16154 
      oprot.writeString(self.searchString)
16155 
      oprot.writeFieldEnd()
16156 
    oprot.writeFieldStop()
16157 
    oprot.writeStructEnd()
16158 
 
16159 
  def validate(self):
16160 
    return
16161 
 
16162 
 
16163 
  def __repr__(self):
16164 
    L = ['%s=%r' % (key, value)
16165 
      for key, value in self.__dict__.iteritems()]
16166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16167 
 
16168 
  def __eq__(self, other):
16169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16170 
 
16171 
  def __ne__(self, other):
16172 
    return not (self == other)
16173 
 
16174 
class searchCounter_result:
16175 
  """
16176 
  Attributes:
16177 
   - success
16178 
  """
16179 
 
16180 
  thrift_spec = (
16181 
    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
16182 
  )
16183 
 
16184 
  def __init__(self, success=None,):
16185 
    self.success = success
16186 
 
16187 
  def read(self, iprot):
16188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16190 
      return
16191 
    iprot.readStructBegin()
16192 
    while True:
16193 
      (fname, ftype, fid) = iprot.readFieldBegin()
16194 
      if ftype == TType.STOP:
16195 
        break
16196 
      if fid == 0:
16197 
        if ftype == TType.LIST:
16198 
          self.success = []
16199 
          (_etype237, _size234) = iprot.readListBegin()
16200 
          for _i238 in xrange(_size234):
16201 
            _elem239 = Counter()
16202 
            _elem239.read(iprot)
16203 
            self.success.append(_elem239)
16204 
          iprot.readListEnd()
16205 
        else:
16206 
          iprot.skip(ftype)
16207 
      else:
16208 
        iprot.skip(ftype)
16209 
      iprot.readFieldEnd()
16210 
    iprot.readStructEnd()
16211 
 
16212 
  def write(self, oprot):
16213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16215 
      return
16216 
    oprot.writeStructBegin('searchCounter_result')
16217 
    if self.success is not None:
16218 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16219 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16220 
      for iter240 in self.success:
16221 
        iter240.write(oprot)
16222 
      oprot.writeListEnd()
16223 
      oprot.writeFieldEnd()
16224 
    oprot.writeFieldStop()
16225 
    oprot.writeStructEnd()
16226 
 
16227 
  def validate(self):
16228 
    return
16229 
 
16230 
 
16231 
  def __repr__(self):
16232 
    L = ['%s=%r' % (key, value)
16233 
      for key, value in self.__dict__.iteritems()]
16234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16235 
 
16236 
  def __eq__(self, other):
16237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16238 
 
16239 
  def __ne__(self, other):
16240 
    return not (self == other)
16241 
 
18977 amit.gupta 16242 
class getCounterByUserId_args:
16243 
  """
16244 
  Attributes:
16245 
   - userId
16246 
  """
16247 
 
16248 
  thrift_spec = (
16249 
    None, # 0
16250 
    (1, TType.I64, 'userId', None, None, ), # 1
16251 
  )
16252 
 
16253 
  def __init__(self, userId=None,):
16254 
    self.userId = userId
16255 
 
16256 
  def read(self, iprot):
16257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16259 
      return
16260 
    iprot.readStructBegin()
16261 
    while True:
16262 
      (fname, ftype, fid) = iprot.readFieldBegin()
16263 
      if ftype == TType.STOP:
16264 
        break
16265 
      if fid == 1:
16266 
        if ftype == TType.I64:
16267 
          self.userId = iprot.readI64();
16268 
        else:
16269 
          iprot.skip(ftype)
16270 
      else:
16271 
        iprot.skip(ftype)
16272 
      iprot.readFieldEnd()
16273 
    iprot.readStructEnd()
16274 
 
16275 
  def write(self, oprot):
16276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16278 
      return
16279 
    oprot.writeStructBegin('getCounterByUserId_args')
16280 
    if self.userId is not None:
16281 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16282 
      oprot.writeI64(self.userId)
16283 
      oprot.writeFieldEnd()
16284 
    oprot.writeFieldStop()
16285 
    oprot.writeStructEnd()
16286 
 
16287 
  def validate(self):
16288 
    return
16289 
 
16290 
 
16291 
  def __repr__(self):
16292 
    L = ['%s=%r' % (key, value)
16293 
      for key, value in self.__dict__.iteritems()]
16294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16295 
 
16296 
  def __eq__(self, other):
16297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16298 
 
16299 
  def __ne__(self, other):
16300 
    return not (self == other)
16301 
 
16302 
class getCounterByUserId_result:
16303 
  """
16304 
  Attributes:
16305 
   - success
16306 
  """
16307 
 
16308 
  thrift_spec = (
16309 
    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
16310 
  )
16311 
 
16312 
  def __init__(self, success=None,):
16313 
    self.success = success
16314 
 
16315 
  def read(self, iprot):
16316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16318 
      return
16319 
    iprot.readStructBegin()
16320 
    while True:
16321 
      (fname, ftype, fid) = iprot.readFieldBegin()
16322 
      if ftype == TType.STOP:
16323 
        break
16324 
      if fid == 0:
16325 
        if ftype == TType.STRUCT:
16326 
          self.success = Counter()
16327 
          self.success.read(iprot)
16328 
        else:
16329 
          iprot.skip(ftype)
16330 
      else:
16331 
        iprot.skip(ftype)
16332 
      iprot.readFieldEnd()
16333 
    iprot.readStructEnd()
16334 
 
16335 
  def write(self, oprot):
16336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16338 
      return
16339 
    oprot.writeStructBegin('getCounterByUserId_result')
16340 
    if self.success is not None:
16341 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16342 
      self.success.write(oprot)
16343 
      oprot.writeFieldEnd()
16344 
    oprot.writeFieldStop()
16345 
    oprot.writeStructEnd()
16346 
 
16347 
  def validate(self):
16348 
    return
16349 
 
16350 
 
16351 
  def __repr__(self):
16352 
    L = ['%s=%r' % (key, value)
16353 
      for key, value in self.__dict__.iteritems()]
16354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16355 
 
16356 
  def __eq__(self, other):
16357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16358 
 
16359 
  def __ne__(self, other):
16360 
    return not (self == other)
16361 
 
12722 amit.gupta 16362 
class getAllUsersByCounter_args:
16363 
  """
16364 
  Attributes:
16365 
   - counterId
16366 
  """
16367 
 
16368 
  thrift_spec = (
16369 
    None, # 0
16370 
    (1, TType.I64, 'counterId', None, None, ), # 1
16371 
  )
16372 
 
16373 
  def __init__(self, counterId=None,):
16374 
    self.counterId = counterId
16375 
 
16376 
  def read(self, iprot):
16377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16379 
      return
16380 
    iprot.readStructBegin()
16381 
    while True:
16382 
      (fname, ftype, fid) = iprot.readFieldBegin()
16383 
      if ftype == TType.STOP:
16384 
        break
16385 
      if fid == 1:
16386 
        if ftype == TType.I64:
16387 
          self.counterId = iprot.readI64();
16388 
        else:
16389 
          iprot.skip(ftype)
16390 
      else:
16391 
        iprot.skip(ftype)
16392 
      iprot.readFieldEnd()
16393 
    iprot.readStructEnd()
16394 
 
16395 
  def write(self, oprot):
16396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16398 
      return
16399 
    oprot.writeStructBegin('getAllUsersByCounter_args')
16400 
    if self.counterId is not None:
16401 
      oprot.writeFieldBegin('counterId', TType.I64, 1)
16402 
      oprot.writeI64(self.counterId)
16403 
      oprot.writeFieldEnd()
16404 
    oprot.writeFieldStop()
16405 
    oprot.writeStructEnd()
16406 
 
16407 
  def validate(self):
16408 
    return
16409 
 
16410 
 
16411 
  def __repr__(self):
16412 
    L = ['%s=%r' % (key, value)
16413 
      for key, value in self.__dict__.iteritems()]
16414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16415 
 
16416 
  def __eq__(self, other):
16417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16418 
 
16419 
  def __ne__(self, other):
16420 
    return not (self == other)
16421 
 
16422 
class getAllUsersByCounter_result:
16423 
  """
16424 
  Attributes:
16425 
   - success
16426 
  """
16427 
 
16428 
  thrift_spec = (
16429 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
16430 
  )
16431 
 
16432 
  def __init__(self, success=None,):
16433 
    self.success = success
16434 
 
16435 
  def read(self, iprot):
16436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16438 
      return
16439 
    iprot.readStructBegin()
16440 
    while True:
16441 
      (fname, ftype, fid) = iprot.readFieldBegin()
16442 
      if ftype == TType.STOP:
16443 
        break
16444 
      if fid == 0:
16445 
        if ftype == TType.LIST:
16446 
          self.success = []
16447 
          (_etype244, _size241) = iprot.readListBegin()
16448 
          for _i245 in xrange(_size241):
16449 
            _elem246 = User()
16450 
            _elem246.read(iprot)
16451 
            self.success.append(_elem246)
16452 
          iprot.readListEnd()
16453 
        else:
16454 
          iprot.skip(ftype)
16455 
      else:
16456 
        iprot.skip(ftype)
16457 
      iprot.readFieldEnd()
16458 
    iprot.readStructEnd()
16459 
 
16460 
  def write(self, oprot):
16461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16463 
      return
16464 
    oprot.writeStructBegin('getAllUsersByCounter_result')
16465 
    if self.success is not None:
16466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16468 
      for iter247 in self.success:
16469 
        iter247.write(oprot)
16470 
      oprot.writeListEnd()
16471 
      oprot.writeFieldEnd()
16472 
    oprot.writeFieldStop()
16473 
    oprot.writeStructEnd()
16474 
 
16475 
  def validate(self):
16476 
    return
16477 
 
16478 
 
16479 
  def __repr__(self):
16480 
    L = ['%s=%r' % (key, value)
16481 
      for key, value in self.__dict__.iteritems()]
16482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16483 
 
16484 
  def __eq__(self, other):
16485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16486 
 
16487 
  def __ne__(self, other):
16488 
    return not (self == other)
15251 manish.sha 16489 
 
16490 
class getActiveAccessTokenForUser_args:
16491 
  """
16492 
  Attributes:
16493 
   - userId
16494 
   - source
16495 
  """
16496 
 
16497 
  thrift_spec = (
16498 
    None, # 0
16499 
    (1, TType.I64, 'userId', None, None, ), # 1
16500 
    (2, TType.STRING, 'source', None, None, ), # 2
16501 
  )
16502 
 
16503 
  def __init__(self, userId=None, source=None,):
16504 
    self.userId = userId
16505 
    self.source = source
16506 
 
16507 
  def read(self, iprot):
16508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16510 
      return
16511 
    iprot.readStructBegin()
16512 
    while True:
16513 
      (fname, ftype, fid) = iprot.readFieldBegin()
16514 
      if ftype == TType.STOP:
16515 
        break
16516 
      if fid == 1:
16517 
        if ftype == TType.I64:
16518 
          self.userId = iprot.readI64();
16519 
        else:
16520 
          iprot.skip(ftype)
16521 
      elif fid == 2:
16522 
        if ftype == TType.STRING:
16523 
          self.source = iprot.readString();
16524 
        else:
16525 
          iprot.skip(ftype)
16526 
      else:
16527 
        iprot.skip(ftype)
16528 
      iprot.readFieldEnd()
16529 
    iprot.readStructEnd()
16530 
 
16531 
  def write(self, oprot):
16532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16534 
      return
16535 
    oprot.writeStructBegin('getActiveAccessTokenForUser_args')
16536 
    if self.userId is not None:
16537 
      oprot.writeFieldBegin('userId', TType.I64, 1)
16538 
      oprot.writeI64(self.userId)
16539 
      oprot.writeFieldEnd()
16540 
    if self.source is not None:
16541 
      oprot.writeFieldBegin('source', TType.STRING, 2)
16542 
      oprot.writeString(self.source)
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 getActiveAccessTokenForUser_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('getActiveAccessTokenForUser_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)
16620 
 
16621 
class validateAccessToken_args:
16622 
  """
16623 
  Attributes:
16624 
   - accessToken
16625 
  """
16626 
 
16627 
  thrift_spec = (
16628 
    None, # 0
16629 
    (1, TType.STRING, 'accessToken', None, None, ), # 1
16630 
  )
16631 
 
16632 
  def __init__(self, accessToken=None,):
16633 
    self.accessToken = accessToken
16634 
 
16635 
  def read(self, iprot):
16636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16638 
      return
16639 
    iprot.readStructBegin()
16640 
    while True:
16641 
      (fname, ftype, fid) = iprot.readFieldBegin()
16642 
      if ftype == TType.STOP:
16643 
        break
16644 
      if fid == 1:
16645 
        if ftype == TType.STRING:
16646 
          self.accessToken = iprot.readString();
16647 
        else:
16648 
          iprot.skip(ftype)
16649 
      else:
16650 
        iprot.skip(ftype)
16651 
      iprot.readFieldEnd()
16652 
    iprot.readStructEnd()
16653 
 
16654 
  def write(self, oprot):
16655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16657 
      return
16658 
    oprot.writeStructBegin('validateAccessToken_args')
16659 
    if self.accessToken is not None:
16660 
      oprot.writeFieldBegin('accessToken', TType.STRING, 1)
16661 
      oprot.writeString(self.accessToken)
16662 
      oprot.writeFieldEnd()
16663 
    oprot.writeFieldStop()
16664 
    oprot.writeStructEnd()
16665 
 
16666 
  def validate(self):
16667 
    return
16668 
 
16669 
 
16670 
  def __repr__(self):
16671 
    L = ['%s=%r' % (key, value)
16672 
      for key, value in self.__dict__.iteritems()]
16673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16674 
 
16675 
  def __eq__(self, other):
16676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16677 
 
16678 
  def __ne__(self, other):
16679 
    return not (self == other)
16680 
 
16681 
class validateAccessToken_result:
16682 
  """
16683 
  Attributes:
16684 
   - success
16685 
  """
16686 
 
16687 
  thrift_spec = (
16688 
    (0, TType.BOOL, 'success', None, None, ), # 0
16689 
  )
16690 
 
16691 
  def __init__(self, success=None,):
16692 
    self.success = success
16693 
 
16694 
  def read(self, iprot):
16695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16697 
      return
16698 
    iprot.readStructBegin()
16699 
    while True:
16700 
      (fname, ftype, fid) = iprot.readFieldBegin()
16701 
      if ftype == TType.STOP:
16702 
        break
16703 
      if fid == 0:
16704 
        if ftype == TType.BOOL:
16705 
          self.success = iprot.readBool();
16706 
        else:
16707 
          iprot.skip(ftype)
16708 
      else:
16709 
        iprot.skip(ftype)
16710 
      iprot.readFieldEnd()
16711 
    iprot.readStructEnd()
16712 
 
16713 
  def write(self, oprot):
16714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16716 
      return
16717 
    oprot.writeStructBegin('validateAccessToken_result')
16718 
    if self.success is not None:
16719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16720 
      oprot.writeBool(self.success)
16721 
      oprot.writeFieldEnd()
16722 
    oprot.writeFieldStop()
16723 
    oprot.writeStructEnd()
16724 
 
16725 
  def validate(self):
16726 
    return
16727 
 
16728 
 
16729 
  def __repr__(self):
16730 
    L = ['%s=%r' % (key, value)
16731 
      for key, value in self.__dict__.iteritems()]
16732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16733 
 
16734 
  def __eq__(self, other):
16735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16736 
 
16737 
  def __ne__(self, other):
16738 
    return not (self == other)
17782 amit.gupta 16739 
 
16740 
class addItemsToCart_args:
16741 
  """
16742 
  Attributes:
16743 
   - cartId
16744 
   - itemQty
16745 
   - couponCode
16746 
  """
16747 
 
16748 
  thrift_spec = (
16749 
    None, # 0
16750 
    (1, TType.I64, 'cartId', None, None, ), # 1
16751 
    (2, TType.LIST, 'itemQty', (TType.STRUCT,(ItemQuantity, ItemQuantity.thrift_spec)), None, ), # 2
16752 
    (3, TType.STRING, 'couponCode', None, None, ), # 3
16753 
  )
16754 
 
16755 
  def __init__(self, cartId=None, itemQty=None, couponCode=None,):
16756 
    self.cartId = cartId
16757 
    self.itemQty = itemQty
16758 
    self.couponCode = couponCode
16759 
 
16760 
  def read(self, iprot):
16761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16763 
      return
16764 
    iprot.readStructBegin()
16765 
    while True:
16766 
      (fname, ftype, fid) = iprot.readFieldBegin()
16767 
      if ftype == TType.STOP:
16768 
        break
16769 
      if fid == 1:
16770 
        if ftype == TType.I64:
16771 
          self.cartId = iprot.readI64();
16772 
        else:
16773 
          iprot.skip(ftype)
16774 
      elif fid == 2:
16775 
        if ftype == TType.LIST:
16776 
          self.itemQty = []
16777 
          (_etype251, _size248) = iprot.readListBegin()
16778 
          for _i252 in xrange(_size248):
16779 
            _elem253 = ItemQuantity()
16780 
            _elem253.read(iprot)
16781 
            self.itemQty.append(_elem253)
16782 
          iprot.readListEnd()
16783 
        else:
16784 
          iprot.skip(ftype)
16785 
      elif fid == 3:
16786 
        if ftype == TType.STRING:
16787 
          self.couponCode = iprot.readString();
16788 
        else:
16789 
          iprot.skip(ftype)
16790 
      else:
16791 
        iprot.skip(ftype)
16792 
      iprot.readFieldEnd()
16793 
    iprot.readStructEnd()
16794 
 
16795 
  def write(self, oprot):
16796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16798 
      return
16799 
    oprot.writeStructBegin('addItemsToCart_args')
16800 
    if self.cartId is not None:
16801 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16802 
      oprot.writeI64(self.cartId)
16803 
      oprot.writeFieldEnd()
16804 
    if self.itemQty is not None:
16805 
      oprot.writeFieldBegin('itemQty', TType.LIST, 2)
16806 
      oprot.writeListBegin(TType.STRUCT, len(self.itemQty))
16807 
      for iter254 in self.itemQty:
16808 
        iter254.write(oprot)
16809 
      oprot.writeListEnd()
16810 
      oprot.writeFieldEnd()
16811 
    if self.couponCode is not None:
16812 
      oprot.writeFieldBegin('couponCode', TType.STRING, 3)
16813 
      oprot.writeString(self.couponCode)
16814 
      oprot.writeFieldEnd()
16815 
    oprot.writeFieldStop()
16816 
    oprot.writeStructEnd()
16817 
 
16818 
  def validate(self):
16819 
    return
16820 
 
16821 
 
16822 
  def __repr__(self):
16823 
    L = ['%s=%r' % (key, value)
16824 
      for key, value in self.__dict__.iteritems()]
16825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16826 
 
16827 
  def __eq__(self, other):
16828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16829 
 
16830 
  def __ne__(self, other):
16831 
    return not (self == other)
16832 
 
16833 
class addItemsToCart_result:
16834 
  """
16835 
  Attributes:
16836 
   - success
16837 
  """
16838 
 
16839 
  thrift_spec = (
16840 
    (0, TType.BOOL, 'success', None, None, ), # 0
16841 
  )
16842 
 
16843 
  def __init__(self, success=None,):
16844 
    self.success = success
16845 
 
16846 
  def read(self, iprot):
16847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16849 
      return
16850 
    iprot.readStructBegin()
16851 
    while True:
16852 
      (fname, ftype, fid) = iprot.readFieldBegin()
16853 
      if ftype == TType.STOP:
16854 
        break
16855 
      if fid == 0:
16856 
        if ftype == TType.BOOL:
16857 
          self.success = iprot.readBool();
16858 
        else:
16859 
          iprot.skip(ftype)
16860 
      else:
16861 
        iprot.skip(ftype)
16862 
      iprot.readFieldEnd()
16863 
    iprot.readStructEnd()
16864 
 
16865 
  def write(self, oprot):
16866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16868 
      return
16869 
    oprot.writeStructBegin('addItemsToCart_result')
16870 
    if self.success is not None:
16871 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16872 
      oprot.writeBool(self.success)
16873 
      oprot.writeFieldEnd()
16874 
    oprot.writeFieldStop()
16875 
    oprot.writeStructEnd()
16876 
 
16877 
  def validate(self):
16878 
    return
16879 
 
16880 
 
16881 
  def __repr__(self):
16882 
    L = ['%s=%r' % (key, value)
16883 
      for key, value in self.__dict__.iteritems()]
16884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16885 
 
16886 
  def __eq__(self, other):
16887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16888 
 
16889 
  def __ne__(self, other):
16890 
    return not (self == other)
16891 
 
16892 
class validateCartNew_args:
16893 
  """
16894 
  Attributes:
16895 
   - cartId
16896 
   - pinCode
16897 
   - sourceId
16898 
  """
16899 
 
16900 
  thrift_spec = (
16901 
    None, # 0
16902 
    (1, TType.I64, 'cartId', None, None, ), # 1
16903 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
16904 
    (3, TType.I64, 'sourceId', None, None, ), # 3
16905 
  )
16906 
 
16907 
  def __init__(self, cartId=None, pinCode=None, sourceId=None,):
16908 
    self.cartId = cartId
16909 
    self.pinCode = pinCode
16910 
    self.sourceId = sourceId
16911 
 
16912 
  def read(self, iprot):
16913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16915 
      return
16916 
    iprot.readStructBegin()
16917 
    while True:
16918 
      (fname, ftype, fid) = iprot.readFieldBegin()
16919 
      if ftype == TType.STOP:
16920 
        break
16921 
      if fid == 1:
16922 
        if ftype == TType.I64:
16923 
          self.cartId = iprot.readI64();
16924 
        else:
16925 
          iprot.skip(ftype)
16926 
      elif fid == 2:
16927 
        if ftype == TType.STRING:
16928 
          self.pinCode = iprot.readString();
16929 
        else:
16930 
          iprot.skip(ftype)
16931 
      elif fid == 3:
16932 
        if ftype == TType.I64:
16933 
          self.sourceId = iprot.readI64();
16934 
        else:
16935 
          iprot.skip(ftype)
16936 
      else:
16937 
        iprot.skip(ftype)
16938 
      iprot.readFieldEnd()
16939 
    iprot.readStructEnd()
16940 
 
16941 
  def write(self, oprot):
16942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16944 
      return
16945 
    oprot.writeStructBegin('validateCartNew_args')
16946 
    if self.cartId is not None:
16947 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
16948 
      oprot.writeI64(self.cartId)
16949 
      oprot.writeFieldEnd()
16950 
    if self.pinCode is not None:
16951 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
16952 
      oprot.writeString(self.pinCode)
16953 
      oprot.writeFieldEnd()
16954 
    if self.sourceId is not None:
16955 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
16956 
      oprot.writeI64(self.sourceId)
16957 
      oprot.writeFieldEnd()
16958 
    oprot.writeFieldStop()
16959 
    oprot.writeStructEnd()
16960 
 
16961 
  def validate(self):
16962 
    return
16963 
 
16964 
 
16965 
  def __repr__(self):
16966 
    L = ['%s=%r' % (key, value)
16967 
      for key, value in self.__dict__.iteritems()]
16968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16969 
 
16970 
  def __eq__(self, other):
16971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16972 
 
16973 
  def __ne__(self, other):
16974 
    return not (self == other)
16975 
 
16976 
class validateCartNew_result:
16977 
  """
16978 
  Attributes:
16979 
   - success
16980 
  """
16981 
 
16982 
  thrift_spec = (
16983 
    (0, TType.STRING, 'success', None, None, ), # 0
16984 
  )
16985 
 
16986 
  def __init__(self, success=None,):
16987 
    self.success = success
16988 
 
16989 
  def read(self, iprot):
16990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16992 
      return
16993 
    iprot.readStructBegin()
16994 
    while True:
16995 
      (fname, ftype, fid) = iprot.readFieldBegin()
16996 
      if ftype == TType.STOP:
16997 
        break
16998 
      if fid == 0:
16999 
        if ftype == TType.STRING:
17000 
          self.success = iprot.readString();
17001 
        else:
17002 
          iprot.skip(ftype)
17003 
      else:
17004 
        iprot.skip(ftype)
17005 
      iprot.readFieldEnd()
17006 
    iprot.readStructEnd()
17007 
 
17008 
  def write(self, oprot):
17009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17011 
      return
17012 
    oprot.writeStructBegin('validateCartNew_result')
17013 
    if self.success is not None:
17014 
      oprot.writeFieldBegin('success', TType.STRING, 0)
17015 
      oprot.writeString(self.success)
17016 
      oprot.writeFieldEnd()
17017 
    oprot.writeFieldStop()
17018 
    oprot.writeStructEnd()
17019 
 
17020 
  def validate(self):
17021 
    return
17022 
 
17023 
 
17024 
  def __repr__(self):
17025 
    L = ['%s=%r' % (key, value)
17026 
      for key, value in self.__dict__.iteritems()]
17027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17028 
 
17029 
  def __eq__(self, other):
17030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17031 
 
17032 
  def __ne__(self, other):
17033 
    return not (self == other)
18530 manish.sha 17034 
 
18644 manish.sha 17035 
class isAddressEditableForCounter_args:
18530 manish.sha 17036 
  """
17037 
  Attributes:
17038 
   - userId
17039 
  """
17040 
 
17041 
  thrift_spec = (
17042 
    None, # 0
17043 
    (1, TType.I64, 'userId', None, None, ), # 1
17044 
  )
17045 
 
17046 
  def __init__(self, userId=None,):
17047 
    self.userId = userId
17048 
 
17049 
  def read(self, iprot):
17050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17052 
      return
17053 
    iprot.readStructBegin()
17054 
    while True:
17055 
      (fname, ftype, fid) = iprot.readFieldBegin()
17056 
      if ftype == TType.STOP:
17057 
        break
17058 
      if fid == 1:
17059 
        if ftype == TType.I64:
17060 
          self.userId = iprot.readI64();
17061 
        else:
17062 
          iprot.skip(ftype)
17063 
      else:
17064 
        iprot.skip(ftype)
17065 
      iprot.readFieldEnd()
17066 
    iprot.readStructEnd()
17067 
 
17068 
  def write(self, oprot):
17069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17071 
      return
18644 manish.sha 17072 
    oprot.writeStructBegin('isAddressEditableForCounter_args')
18530 manish.sha 17073 
    if self.userId is not None:
17074 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17075 
      oprot.writeI64(self.userId)
17076 
      oprot.writeFieldEnd()
17077 
    oprot.writeFieldStop()
17078 
    oprot.writeStructEnd()
17079 
 
17080 
  def validate(self):
17081 
    return
17082 
 
17083 
 
17084 
  def __repr__(self):
17085 
    L = ['%s=%r' % (key, value)
17086 
      for key, value in self.__dict__.iteritems()]
17087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17088 
 
17089 
  def __eq__(self, other):
17090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17091 
 
17092 
  def __ne__(self, other):
17093 
    return not (self == other)
17094 
 
18644 manish.sha 17095 
class isAddressEditableForCounter_result:
18530 manish.sha 17096 
  """
17097 
  Attributes:
17098 
   - success
17099 
  """
17100 
 
17101 
  thrift_spec = (
17102 
    (0, TType.BOOL, 'success', None, None, ), # 0
17103 
  )
17104 
 
17105 
  def __init__(self, success=None,):
17106 
    self.success = success
17107 
 
17108 
  def read(self, iprot):
17109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17111 
      return
17112 
    iprot.readStructBegin()
17113 
    while True:
17114 
      (fname, ftype, fid) = iprot.readFieldBegin()
17115 
      if ftype == TType.STOP:
17116 
        break
17117 
      if fid == 0:
17118 
        if ftype == TType.BOOL:
17119 
          self.success = iprot.readBool();
17120 
        else:
17121 
          iprot.skip(ftype)
17122 
      else:
17123 
        iprot.skip(ftype)
17124 
      iprot.readFieldEnd()
17125 
    iprot.readStructEnd()
17126 
 
17127 
  def write(self, oprot):
17128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17130 
      return
18644 manish.sha 17131 
    oprot.writeStructBegin('isAddressEditableForCounter_result')
18530 manish.sha 17132 
    if self.success is not None:
17133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17134 
      oprot.writeBool(self.success)
17135 
      oprot.writeFieldEnd()
17136 
    oprot.writeFieldStop()
17137 
    oprot.writeStructEnd()
17138 
 
17139 
  def validate(self):
17140 
    return
17141 
 
17142 
 
17143 
  def __repr__(self):
17144 
    L = ['%s=%r' % (key, value)
17145 
      for key, value in self.__dict__.iteritems()]
17146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17147 
 
17148 
  def __eq__(self, other):
17149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17150 
 
17151 
  def __ne__(self, other):
17152 
    return not (self == other)
17153 
 
17154 
class getBillingAddressForUser_args:
17155 
  """
17156 
  Attributes:
17157 
   - userId
17158 
  """
17159 
 
17160 
  thrift_spec = (
17161 
    None, # 0
17162 
    (1, TType.I64, 'userId', None, None, ), # 1
17163 
  )
17164 
 
17165 
  def __init__(self, userId=None,):
17166 
    self.userId = userId
17167 
 
17168 
  def read(self, iprot):
17169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17171 
      return
17172 
    iprot.readStructBegin()
17173 
    while True:
17174 
      (fname, ftype, fid) = iprot.readFieldBegin()
17175 
      if ftype == TType.STOP:
17176 
        break
17177 
      if fid == 1:
17178 
        if ftype == TType.I64:
17179 
          self.userId = iprot.readI64();
17180 
        else:
17181 
          iprot.skip(ftype)
17182 
      else:
17183 
        iprot.skip(ftype)
17184 
      iprot.readFieldEnd()
17185 
    iprot.readStructEnd()
17186 
 
17187 
  def write(self, oprot):
17188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17190 
      return
17191 
    oprot.writeStructBegin('getBillingAddressForUser_args')
17192 
    if self.userId is not None:
17193 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17194 
      oprot.writeI64(self.userId)
17195 
      oprot.writeFieldEnd()
17196 
    oprot.writeFieldStop()
17197 
    oprot.writeStructEnd()
17198 
 
17199 
  def validate(self):
17200 
    return
17201 
 
17202 
 
17203 
  def __repr__(self):
17204 
    L = ['%s=%r' % (key, value)
17205 
      for key, value in self.__dict__.iteritems()]
17206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17207 
 
17208 
  def __eq__(self, other):
17209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17210 
 
17211 
  def __ne__(self, other):
17212 
    return not (self == other)
17213 
 
17214 
class getBillingAddressForUser_result:
17215 
  """
17216 
  Attributes:
17217 
   - success
17218 
  """
17219 
 
17220 
  thrift_spec = (
17221 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
17222 
  )
17223 
 
17224 
  def __init__(self, success=None,):
17225 
    self.success = success
17226 
 
17227 
  def read(self, iprot):
17228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17230 
      return
17231 
    iprot.readStructBegin()
17232 
    while True:
17233 
      (fname, ftype, fid) = iprot.readFieldBegin()
17234 
      if ftype == TType.STOP:
17235 
        break
17236 
      if fid == 0:
17237 
        if ftype == TType.STRUCT:
17238 
          self.success = Address()
17239 
          self.success.read(iprot)
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('getBillingAddressForUser_result')
17252 
    if self.success is not None:
17253 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17254 
      self.success.write(oprot)
17255 
      oprot.writeFieldEnd()
17256 
    oprot.writeFieldStop()
17257 
    oprot.writeStructEnd()
17258 
 
17259 
  def validate(self):
17260 
    return
17261 
 
17262 
 
17263 
  def __repr__(self):
17264 
    L = ['%s=%r' % (key, value)
17265 
      for key, value in self.__dict__.iteritems()]
17266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17267 
 
17268 
  def __eq__(self, other):
17269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17270 
 
17271 
  def __ne__(self, other):
17272 
    return not (self == other)
18590 manish.sha 17273 
 
17274 
class isCreditorAssigned_args:
17275 
  """
17276 
  Attributes:
17277 
   - userId
17278 
  """
17279 
 
17280 
  thrift_spec = (
17281 
    None, # 0
17282 
    (1, TType.I64, 'userId', None, None, ), # 1
17283 
  )
17284 
 
17285 
  def __init__(self, userId=None,):
17286 
    self.userId = userId
17287 
 
17288 
  def read(self, iprot):
17289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17291 
      return
17292 
    iprot.readStructBegin()
17293 
    while True:
17294 
      (fname, ftype, fid) = iprot.readFieldBegin()
17295 
      if ftype == TType.STOP:
17296 
        break
17297 
      if fid == 1:
17298 
        if ftype == TType.I64:
17299 
          self.userId = iprot.readI64();
17300 
        else:
17301 
          iprot.skip(ftype)
17302 
      else:
17303 
        iprot.skip(ftype)
17304 
      iprot.readFieldEnd()
17305 
    iprot.readStructEnd()
17306 
 
17307 
  def write(self, oprot):
17308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17310 
      return
17311 
    oprot.writeStructBegin('isCreditorAssigned_args')
17312 
    if self.userId is not None:
17313 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17314 
      oprot.writeI64(self.userId)
17315 
      oprot.writeFieldEnd()
17316 
    oprot.writeFieldStop()
17317 
    oprot.writeStructEnd()
17318 
 
17319 
  def validate(self):
17320 
    return
17321 
 
17322 
 
17323 
  def __repr__(self):
17324 
    L = ['%s=%r' % (key, value)
17325 
      for key, value in self.__dict__.iteritems()]
17326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17327 
 
17328 
  def __eq__(self, other):
17329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17330 
 
17331 
  def __ne__(self, other):
17332 
    return not (self == other)
17333 
 
17334 
class isCreditorAssigned_result:
17335 
  """
17336 
  Attributes:
17337 
   - success
17338 
  """
17339 
 
17340 
  thrift_spec = (
17341 
    (0, TType.BOOL, 'success', None, None, ), # 0
17342 
  )
17343 
 
17344 
  def __init__(self, success=None,):
17345 
    self.success = success
17346 
 
17347 
  def read(self, iprot):
17348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17350 
      return
17351 
    iprot.readStructBegin()
17352 
    while True:
17353 
      (fname, ftype, fid) = iprot.readFieldBegin()
17354 
      if ftype == TType.STOP:
17355 
        break
17356 
      if fid == 0:
17357 
        if ftype == TType.BOOL:
17358 
          self.success = iprot.readBool();
17359 
        else:
17360 
          iprot.skip(ftype)
17361 
      else:
17362 
        iprot.skip(ftype)
17363 
      iprot.readFieldEnd()
17364 
    iprot.readStructEnd()
17365 
 
17366 
  def write(self, oprot):
17367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17369 
      return
17370 
    oprot.writeStructBegin('isCreditorAssigned_result')
17371 
    if self.success is not None:
17372 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17373 
      oprot.writeBool(self.success)
17374 
      oprot.writeFieldEnd()
17375 
    oprot.writeFieldStop()
17376 
    oprot.writeStructEnd()
17377 
 
17378 
  def validate(self):
17379 
    return
17380 
 
17381 
 
17382 
  def __repr__(self):
17383 
    L = ['%s=%r' % (key, value)
17384 
      for key, value in self.__dict__.iteritems()]
17385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17386 
 
17387 
  def __eq__(self, other):
17388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17389 
 
17390 
  def __ne__(self, other):
17391 
    return not (self == other)
18735 manish.sha 17392 
 
17393 
class isTaxInvoiceEnabledUser_args:
17394 
  """
17395 
  Attributes:
17396 
   - userId
17397 
  """
17398 
 
17399 
  thrift_spec = (
17400 
    None, # 0
17401 
    (1, TType.I64, 'userId', None, None, ), # 1
17402 
  )
17403 
 
17404 
  def __init__(self, userId=None,):
17405 
    self.userId = userId
17406 
 
17407 
  def read(self, iprot):
17408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17410 
      return
17411 
    iprot.readStructBegin()
17412 
    while True:
17413 
      (fname, ftype, fid) = iprot.readFieldBegin()
17414 
      if ftype == TType.STOP:
17415 
        break
17416 
      if fid == 1:
17417 
        if ftype == TType.I64:
17418 
          self.userId = iprot.readI64();
17419 
        else:
17420 
          iprot.skip(ftype)
17421 
      else:
17422 
        iprot.skip(ftype)
17423 
      iprot.readFieldEnd()
17424 
    iprot.readStructEnd()
17425 
 
17426 
  def write(self, oprot):
17427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17429 
      return
17430 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_args')
17431 
    if self.userId is not None:
17432 
      oprot.writeFieldBegin('userId', TType.I64, 1)
17433 
      oprot.writeI64(self.userId)
17434 
      oprot.writeFieldEnd()
17435 
    oprot.writeFieldStop()
17436 
    oprot.writeStructEnd()
17437 
 
17438 
  def validate(self):
17439 
    return
17440 
 
17441 
 
17442 
  def __repr__(self):
17443 
    L = ['%s=%r' % (key, value)
17444 
      for key, value in self.__dict__.iteritems()]
17445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17446 
 
17447 
  def __eq__(self, other):
17448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17449 
 
17450 
  def __ne__(self, other):
17451 
    return not (self == other)
17452 
 
17453 
class isTaxInvoiceEnabledUser_result:
17454 
  """
17455 
  Attributes:
17456 
   - success
17457 
  """
17458 
 
17459 
  thrift_spec = (
17460 
    (0, TType.BOOL, 'success', None, None, ), # 0
17461 
  )
17462 
 
17463 
  def __init__(self, success=None,):
17464 
    self.success = success
17465 
 
17466 
  def read(self, iprot):
17467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17469 
      return
17470 
    iprot.readStructBegin()
17471 
    while True:
17472 
      (fname, ftype, fid) = iprot.readFieldBegin()
17473 
      if ftype == TType.STOP:
17474 
        break
17475 
      if fid == 0:
17476 
        if ftype == TType.BOOL:
17477 
          self.success = iprot.readBool();
17478 
        else:
17479 
          iprot.skip(ftype)
17480 
      else:
17481 
        iprot.skip(ftype)
17482 
      iprot.readFieldEnd()
17483 
    iprot.readStructEnd()
17484 
 
17485 
  def write(self, oprot):
17486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17488 
      return
17489 
    oprot.writeStructBegin('isTaxInvoiceEnabledUser_result')
17490 
    if self.success is not None:
17491 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17492 
      oprot.writeBool(self.success)
17493 
      oprot.writeFieldEnd()
17494 
    oprot.writeFieldStop()
17495 
    oprot.writeStructEnd()
17496 
 
17497 
  def validate(self):
17498 
    return
17499 
 
17500 
 
17501 
  def __repr__(self):
17502 
    L = ['%s=%r' % (key, value)
17503 
      for key, value in self.__dict__.iteritems()]
17504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17505 
 
17506 
  def __eq__(self, other):
17507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17508 
 
17509 
  def __ne__(self, other):
17510 
    return not (self == other)
18764 kshitij.so 17511 
 
17512 
class getCartByValue_args:
17513 
  """
17514 
  Attributes:
17515 
   - cartIds
17516 
  """
17517 
 
17518 
  thrift_spec = (
17519 
    None, # 0
17520 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
17521 
  )
17522 
 
17523 
  def __init__(self, cartIds=None,):
17524 
    self.cartIds = cartIds
17525 
 
17526 
  def read(self, iprot):
17527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17529 
      return
17530 
    iprot.readStructBegin()
17531 
    while True:
17532 
      (fname, ftype, fid) = iprot.readFieldBegin()
17533 
      if ftype == TType.STOP:
17534 
        break
17535 
      if fid == 1:
17536 
        if ftype == TType.LIST:
17537 
          self.cartIds = []
17538 
          (_etype258, _size255) = iprot.readListBegin()
17539 
          for _i259 in xrange(_size255):
17540 
            _elem260 = iprot.readI64();
17541 
            self.cartIds.append(_elem260)
17542 
          iprot.readListEnd()
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      else:
17546 
        iprot.skip(ftype)
17547 
      iprot.readFieldEnd()
17548 
    iprot.readStructEnd()
17549 
 
17550 
  def write(self, oprot):
17551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17553 
      return
17554 
    oprot.writeStructBegin('getCartByValue_args')
17555 
    if self.cartIds is not None:
17556 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
17557 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
17558 
      for iter261 in self.cartIds:
17559 
        oprot.writeI64(iter261)
17560 
      oprot.writeListEnd()
17561 
      oprot.writeFieldEnd()
17562 
    oprot.writeFieldStop()
17563 
    oprot.writeStructEnd()
17564 
 
17565 
  def validate(self):
17566 
    return
17567 
 
17568 
 
17569 
  def __repr__(self):
17570 
    L = ['%s=%r' % (key, value)
17571 
      for key, value in self.__dict__.iteritems()]
17572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17573 
 
17574 
  def __eq__(self, other):
17575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17576 
 
17577 
  def __ne__(self, other):
17578 
    return not (self == other)
17579 
 
17580 
class getCartByValue_result:
17581 
  """
17582 
  Attributes:
17583 
   - success
17584 
  """
17585 
 
17586 
  thrift_spec = (
17587 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(Line, Line.thrift_spec))), None, ), # 0
17588 
  )
17589 
 
17590 
  def __init__(self, success=None,):
17591 
    self.success = success
17592 
 
17593 
  def read(self, iprot):
17594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17596 
      return
17597 
    iprot.readStructBegin()
17598 
    while True:
17599 
      (fname, ftype, fid) = iprot.readFieldBegin()
17600 
      if ftype == TType.STOP:
17601 
        break
17602 
      if fid == 0:
17603 
        if ftype == TType.MAP:
17604 
          self.success = {}
17605 
          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
17606 
          for _i266 in xrange(_size262):
17607 
            _key267 = iprot.readI64();
17608 
            _val268 = []
17609 
            (_etype272, _size269) = iprot.readListBegin()
17610 
            for _i273 in xrange(_size269):
17611 
              _elem274 = Line()
17612 
              _elem274.read(iprot)
17613 
              _val268.append(_elem274)
17614 
            iprot.readListEnd()
17615 
            self.success[_key267] = _val268
17616 
          iprot.readMapEnd()
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('getCartByValue_result')
17629 
    if self.success is not None:
17630 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17631 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
17632 
      for kiter275,viter276 in self.success.items():
17633 
        oprot.writeI64(kiter275)
17634 
        oprot.writeListBegin(TType.STRUCT, len(viter276))
17635 
        for iter277 in viter276:
17636 
          iter277.write(oprot)
17637 
        oprot.writeListEnd()
17638 
      oprot.writeMapEnd()
17639 
      oprot.writeFieldEnd()
17640 
    oprot.writeFieldStop()
17641 
    oprot.writeStructEnd()
17642 
 
17643 
  def validate(self):
17644 
    return
17645 
 
17646 
 
17647 
  def __repr__(self):
17648 
    L = ['%s=%r' % (key, value)
17649 
      for key, value in self.__dict__.iteritems()]
17650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17651 
 
17652 
  def __eq__(self, other):
17653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17654 
 
17655 
  def __ne__(self, other):
17656 
    return not (self == other)